﻿






// -----------------------------------------------------------------------------
// Autogenerated code. Do not modify.
// -----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;

namespace Basic.Azure.Storage.Communications.ServiceExceptions
{

/// <summary>
/// Maps a WebException from Azure to the appropriate local exception type
/// </summary>
/// <remarks>
/// Uses the Blob Service Error Codes defined here: http://msdn.microsoft.com/en-us/library/windowsazure/dd179439.aspx
/// </remarks>
public static class BlobServiceAzureExceptions
{

	public static AzureException GetExceptionFor(string requestId, HttpStatusCode statusCode, string errorCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
	{
		switch(errorCode)
		{
		 
			case "InvalidBlobOrBlock":
				return new InvalidBlobOrBlockAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "InvalidBlockId":
				return new InvalidBlockIdAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "InvalidBlockList":
				return new InvalidBlockListAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "ContainerNotFound":
				return new ContainerNotFoundAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "BlobNotFound":
				return new BlobNotFoundAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "ContainerAlreadyExists":
				return new ContainerAlreadyExistsAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "ContainerDisabled":
				return new ContainerDisabledAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "ContainerBeingDeleted":
				return new ContainerBeingDeletedAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "BlobAlreadyExists":
				return new BlobAlreadyExistsAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseNotPresentWithBlobOperation":
				return new LeaseNotPresentWithBlobOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseNotPresentWithContainerOperation":
				return new LeaseNotPresentWithContainerOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseLost":
				return new LeaseLostAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseIdMismatchWithBlobOperation":
				return new LeaseIdMismatchWithBlobOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseIdMismatchWithContainerOperation":
				return new LeaseIdMismatchWithContainerOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseIdMissing":
				return new LeaseIdMissingAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseNotPresentWithLeaseOperation":
				return new LeaseNotPresentWithLeaseOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseIdMismatchWithLeaseOperation":
				return new LeaseIdMismatchWithLeaseOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseAlreadyPresent":
				return new LeaseAlreadyPresentAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseAlreadyBroken":
				return new LeaseAlreadyBrokenAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseIsBrokenAndCannotBeRenewed":
				return new LeaseIsBrokenAndCannotBeRenewedAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseIsBreakingAndCannotBeAquired":
				return new LeaseIsBreakingAndCannotBeAquiredAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "LeaseIsBreakingAndCannotBeChanged":
				return new LeaseIsBreakingAndCannotBeChangedAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "InfiniteLeaseDurationRequired":
				return new InfiniteLeaseDurationRequiredAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "SnapshotsPresent":
				return new SnapshotsPresentAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "InvalidBlobType":
				return new InvalidBlobTypeAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "InvalidVersionForPageBlobOperation":
				return new InvalidVersionForPageBlobOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "InvalidPageRange":
				return new InvalidPageRangeAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "SequenceNumberConditionNotMet":
				return new SequenceNumberConditionNotMetAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "SequenceNumberIncrementTooLarge":
				return new SequenceNumberIncrementTooLargeAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "SourceConditionNotMet":
				return new SourceConditionNotMetAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "TargetConditionNotMet":
				return new TargetConditionNotMetAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "CopyAcrossAccountsNotSupported":
				return new CopyAcrossAccountsNotSupportedAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "CannotVerifyCopySource":
				return new CannotVerifyCopySourceAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "PendingCopyOperation":
				return new PendingCopyOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "NoPendingCopyOperation":
				return new NoPendingCopyOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
			 
			case "CopyIdMismatch":
				return new CopyIdMismatchAzureException(requestId, statusCode, statusDescription, details, baseException);
			
		}

		var shortStatusDescription = statusDescription.Split('\n')[0];
		switch(shortStatusDescription)
		{
			 
				case "The specified blob or block content is invalid.":
					return new InvalidBlobOrBlockAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified block ID is invalid. The block ID must be Base64-encoded.":
					return new InvalidBlockIdAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified block list is invalid.":
					return new InvalidBlockListAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified container does not exist.":
					return new ContainerNotFoundAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified blob does not exist.":
					return new BlobNotFoundAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified container already exists.":
					return new ContainerAlreadyExistsAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified container has been disabled by the administrator.":
					return new ContainerDisabledAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified container is being deleted.":
					return new ContainerBeingDeletedAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified blob already exists.":
					return new BlobAlreadyExistsAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "There is currently no lease on the blob.":
					return new LeaseNotPresentWithBlobOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "There is currently no lease on the container.":
					return new LeaseNotPresentWithContainerOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "A lease ID was specified, but the lease for the blob/container has expired.":
					return new LeaseLostAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The lease ID specified did not match the lease ID for the blob.":
					return new LeaseIdMismatchWithBlobOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The lease ID specified did not match the lease ID for the container.":
					return new LeaseIdMismatchWithContainerOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "There is currently a lease on the blob/container and no lease ID was specified in the request.":
					return new LeaseIdMissingAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "There is currently no lease on the blob/container.":
					return new LeaseNotPresentWithLeaseOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The lease ID specified did not match the lease ID for the blob/container.":
					return new LeaseIdMismatchWithLeaseOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "There is already a lease present.":
					return new LeaseAlreadyPresentAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The lease has already been broken and cannot be broken again.":
					return new LeaseAlreadyBrokenAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The lease ID matched, but the lease has been broken explicitly and cannot be renewed.":
					return new LeaseIsBrokenAndCannotBeRenewedAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The lease ID matched, but the lease is currently in breaking state and cannot be acquired until it is broken.":
					return new LeaseIsBreakingAndCannotBeAquiredAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The lease ID matched, but the lease is currently in breaking state and cannot be changed.":
					return new LeaseIsBreakingAndCannotBeChangedAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The lease ID matched, but the specified lease must be an infinite-duration lease.":
					return new InfiniteLeaseDurationRequiredAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "This operation is not permitted because the blob has snapshots.":
					return new SnapshotsPresentAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The blob type is invalid for this operation.":
					return new InvalidBlobTypeAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "All operations on page blobs require at least version 2009-09-19.":
					return new InvalidVersionForPageBlobOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The page range specified is invalid.":
					return new InvalidPageRangeAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The sequence number condition specified was not met.":
					return new SequenceNumberConditionNotMetAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The sequence number increment cannot be performed because it would result in overflow of the sequence number.":
					return new SequenceNumberIncrementTooLargeAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The source condition specified using HTTP conditional header(s) is not met.":
					return new SourceConditionNotMetAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The target condition specified using HTTP conditional header(s) is not met.":
					return new TargetConditionNotMetAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The copy source account and destination account must be the same.":
					return new CopyAcrossAccountsNotSupportedAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "Could not verify the copy source within the specified time. Examine the HTTP status code and message for more information about the failure.":
					return new CannotVerifyCopySourceAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "There is currently a pending copy operation.":
					return new PendingCopyOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "There is currently no pending copy operation.":
					return new NoPendingCopyOperationAzureException(requestId, statusCode, statusDescription, details, baseException);
				 
				case "The specified copy ID did not match the copy ID for the pending copy operation.":
					return new CopyIdMismatchAzureException(requestId, statusCode, statusDescription, details, baseException);
				

			default:
				return CommonServiceAzureExceptions.GetExceptionFor(requestId, statusCode, errorCode, statusDescription, details, baseException);
		}
	}

}


	///
	///<summary>
	///Represents a 'InvalidBlobOrBlock' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified blob or block content is invalid.</remarks>
	public class InvalidBlobOrBlockAzureException : AzureException
    {
        public InvalidBlobOrBlockAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public InvalidBlobOrBlockAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'InvalidBlockId' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified block ID is invalid. The block ID must be Base64-encoded.</remarks>
	public class InvalidBlockIdAzureException : AzureException
    {
        public InvalidBlockIdAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public InvalidBlockIdAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'InvalidBlockList' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified block list is invalid.</remarks>
	public class InvalidBlockListAzureException : AzureException
    {
        public InvalidBlockListAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public InvalidBlockListAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'ContainerNotFound' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified container does not exist.</remarks>
	public class ContainerNotFoundAzureException : AzureException
    {
        public ContainerNotFoundAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public ContainerNotFoundAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'BlobNotFound' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified blob does not exist.</remarks>
	public class BlobNotFoundAzureException : AzureException
    {
        public BlobNotFoundAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public BlobNotFoundAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'ContainerAlreadyExists' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified container already exists.</remarks>
	public class ContainerAlreadyExistsAzureException : AzureException
    {
        public ContainerAlreadyExistsAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public ContainerAlreadyExistsAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'ContainerDisabled' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified container has been disabled by the administrator.</remarks>
	public class ContainerDisabledAzureException : AzureException
    {
        public ContainerDisabledAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public ContainerDisabledAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'ContainerBeingDeleted' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified container is being deleted.</remarks>
	public class ContainerBeingDeletedAzureException : AzureException
    {
        public ContainerBeingDeletedAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public ContainerBeingDeletedAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'BlobAlreadyExists' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified blob already exists.</remarks>
	public class BlobAlreadyExistsAzureException : AzureException
    {
        public BlobAlreadyExistsAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public BlobAlreadyExistsAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseNotPresentWithBlobOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: There is currently no lease on the blob.</remarks>
	public class LeaseNotPresentWithBlobOperationAzureException : AzureException
    {
        public LeaseNotPresentWithBlobOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseNotPresentWithBlobOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseNotPresentWithContainerOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: There is currently no lease on the container.</remarks>
	public class LeaseNotPresentWithContainerOperationAzureException : AzureException
    {
        public LeaseNotPresentWithContainerOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseNotPresentWithContainerOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseLost' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: A lease ID was specified, but the lease for the blob/container has expired.</remarks>
	public class LeaseLostAzureException : AzureException
    {
        public LeaseLostAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseLostAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseIdMismatchWithBlobOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The lease ID specified did not match the lease ID for the blob.</remarks>
	public class LeaseIdMismatchWithBlobOperationAzureException : AzureException
    {
        public LeaseIdMismatchWithBlobOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseIdMismatchWithBlobOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseIdMismatchWithContainerOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The lease ID specified did not match the lease ID for the container.</remarks>
	public class LeaseIdMismatchWithContainerOperationAzureException : AzureException
    {
        public LeaseIdMismatchWithContainerOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseIdMismatchWithContainerOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseIdMissing' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: There is currently a lease on the blob/container and no lease ID was specified in the request.</remarks>
	public class LeaseIdMissingAzureException : AzureException
    {
        public LeaseIdMissingAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseIdMissingAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseNotPresentWithLeaseOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: There is currently no lease on the blob/container.</remarks>
	public class LeaseNotPresentWithLeaseOperationAzureException : AzureException
    {
        public LeaseNotPresentWithLeaseOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseNotPresentWithLeaseOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseIdMismatchWithLeaseOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The lease ID specified did not match the lease ID for the blob/container.</remarks>
	public class LeaseIdMismatchWithLeaseOperationAzureException : AzureException
    {
        public LeaseIdMismatchWithLeaseOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseIdMismatchWithLeaseOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseAlreadyPresent' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: There is already a lease present.</remarks>
	public class LeaseAlreadyPresentAzureException : AzureException
    {
        public LeaseAlreadyPresentAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseAlreadyPresentAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseAlreadyBroken' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The lease has already been broken and cannot be broken again.</remarks>
	public class LeaseAlreadyBrokenAzureException : AzureException
    {
        public LeaseAlreadyBrokenAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseAlreadyBrokenAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseIsBrokenAndCannotBeRenewed' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The lease ID matched, but the lease has been broken explicitly and cannot be renewed.</remarks>
	public class LeaseIsBrokenAndCannotBeRenewedAzureException : AzureException
    {
        public LeaseIsBrokenAndCannotBeRenewedAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseIsBrokenAndCannotBeRenewedAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseIsBreakingAndCannotBeAquired' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The lease ID matched, but the lease is currently in breaking state and cannot be acquired until it is broken.</remarks>
	public class LeaseIsBreakingAndCannotBeAquiredAzureException : AzureException
    {
        public LeaseIsBreakingAndCannotBeAquiredAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseIsBreakingAndCannotBeAquiredAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'LeaseIsBreakingAndCannotBeChanged' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The lease ID matched, but the lease is currently in breaking state and cannot be changed.</remarks>
	public class LeaseIsBreakingAndCannotBeChangedAzureException : AzureException
    {
        public LeaseIsBreakingAndCannotBeChangedAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public LeaseIsBreakingAndCannotBeChangedAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'InfiniteLeaseDurationRequired' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The lease ID matched, but the specified lease must be an infinite-duration lease.</remarks>
	public class InfiniteLeaseDurationRequiredAzureException : AzureException
    {
        public InfiniteLeaseDurationRequiredAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public InfiniteLeaseDurationRequiredAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'SnapshotsPresent' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: This operation is not permitted because the blob has snapshots.</remarks>
	public class SnapshotsPresentAzureException : AzureException
    {
        public SnapshotsPresentAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public SnapshotsPresentAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'InvalidBlobType' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The blob type is invalid for this operation.</remarks>
	public class InvalidBlobTypeAzureException : AzureException
    {
        public InvalidBlobTypeAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public InvalidBlobTypeAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'InvalidVersionForPageBlobOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: All operations on page blobs require at least version 2009-09-19.</remarks>
	public class InvalidVersionForPageBlobOperationAzureException : AzureException
    {
        public InvalidVersionForPageBlobOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public InvalidVersionForPageBlobOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'InvalidPageRange' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The page range specified is invalid.</remarks>
	public class InvalidPageRangeAzureException : AzureException
    {
        public InvalidPageRangeAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public InvalidPageRangeAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'SequenceNumberConditionNotMet' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The sequence number condition specified was not met.</remarks>
	public class SequenceNumberConditionNotMetAzureException : AzureException
    {
        public SequenceNumberConditionNotMetAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public SequenceNumberConditionNotMetAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'SequenceNumberIncrementTooLarge' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The sequence number increment cannot be performed because it would result in overflow of the sequence number.</remarks>
	public class SequenceNumberIncrementTooLargeAzureException : AzureException
    {
        public SequenceNumberIncrementTooLargeAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public SequenceNumberIncrementTooLargeAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'SourceConditionNotMet' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The source condition specified using HTTP conditional header(s) is not met.</remarks>
	public class SourceConditionNotMetAzureException : AzureException
    {
        public SourceConditionNotMetAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public SourceConditionNotMetAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'TargetConditionNotMet' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The target condition specified using HTTP conditional header(s) is not met.</remarks>
	public class TargetConditionNotMetAzureException : AzureException
    {
        public TargetConditionNotMetAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public TargetConditionNotMetAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'CopyAcrossAccountsNotSupported' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The copy source account and destination account must be the same.</remarks>
	public class CopyAcrossAccountsNotSupportedAzureException : AzureException
    {
        public CopyAcrossAccountsNotSupportedAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public CopyAcrossAccountsNotSupportedAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'CannotVerifyCopySource' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: Could not verify the copy source within the specified time. Examine the HTTP status code and message for more information about the failure.</remarks>
	public class CannotVerifyCopySourceAzureException : AzureException
    {
        public CannotVerifyCopySourceAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public CannotVerifyCopySourceAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'PendingCopyOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: There is currently a pending copy operation.</remarks>
	public class PendingCopyOperationAzureException : AzureException
    {
        public PendingCopyOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public PendingCopyOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'NoPendingCopyOperation' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: There is currently no pending copy operation.</remarks>
	public class NoPendingCopyOperationAzureException : AzureException
    {
        public NoPendingCopyOperationAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public NoPendingCopyOperationAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	
	///
	///<summary>
	///Represents a 'CopyIdMismatch' error response from the Blob Service API 
	///</summary>
	///<remarks>Description: The specified copy ID did not match the copy ID for the pending copy operation.</remarks>
	public class CopyIdMismatchAzureException : AzureException
    {
        public CopyIdMismatchAzureException(string requestId, HttpStatusCode statusCode, string statusDescription, Dictionary<string, string> details, WebException baseException)
            : base(requestId, statusCode, statusDescription, details, baseException) { }

		/// <summary>
        /// This constructor is used only to wrap around other Azure Exceptionsd when Microsoft returns the wrong error code and we need to correct it for them
        /// </summary>
		public CopyIdMismatchAzureException(AzureException actualAzureException)
			: base(actualAzureException)
		{ }
    }

	

}