azure_storage_blob/generated/clients/

blob_client.rs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
//
// Code generated by Microsoft (R) Rust Code Generator. DO NOT EDIT.

use crate::generated::models::{
    AccessTier, BlobClientAbortCopyOptions, BlobClientAcquireLeaseOptions,
    BlobClientAcquireLeaseResult, BlobClientBreakLeaseOptions, BlobClientBreakLeaseResult,
    BlobClientChangeLeaseOptions, BlobClientChangeLeaseResult, BlobClientCreateSnapshotOptions,
    BlobClientCreateSnapshotResult, BlobClientDeleteImmutabilityPolicyOptions,
    BlobClientDeleteOptions, BlobClientDownloadInternalOptions, BlobClientDownloadInternalResult,
    BlobClientGetAccountInfoOptions, BlobClientGetAccountInfoResult,
    BlobClientGetPropertiesOptions, BlobClientGetPropertiesResult, BlobClientGetTagsOptions,
    BlobClientReleaseLeaseOptions, BlobClientReleaseLeaseResult, BlobClientRenewLeaseOptions,
    BlobClientRenewLeaseResult, BlobClientSetImmutabilityPolicyOptions,
    BlobClientSetLegalHoldOptions, BlobClientSetMetadataOptions, BlobClientSetPropertiesOptions,
    BlobClientSetTagsOptions, BlobClientSetTierOptions, BlobClientStartCopyFromUrlOptions,
    BlobClientStartCopyFromUrlResult, BlobClientUndeleteOptions, BlobTags,
};
use azure_core::{
    base64,
    error::CheckSuccessOptions,
    fmt::SafeDebug,
    http::{
        AsyncResponse, ClientOptions, Method, NoFormat, Pipeline, PipelineSendOptions,
        PipelineStreamOptions, Request, RequestContent, Response, Url, UrlExt, XmlFormat,
    },
    time::{to_rfc7231, OffsetDateTime},
    tracing, Result,
};
use std::collections::HashMap;

#[tracing::client]
pub struct BlobClient {
    pub(crate) endpoint: Url,
    pub(crate) pipeline: Pipeline,
    pub(crate) version: String,
}

/// Options used when creating a `BlobClient`
#[derive(Clone, SafeDebug)]
pub struct BlobClientOptions {
    /// Allows customization of the client.
    pub client_options: ClientOptions,
    /// Specifies the version of the operation to use for this request.
    pub version: String,
}

impl BlobClient {
    /// Aborts a pending asynchronous copy operation and leaves a destination blob with zero length and full metadata.
    ///
    /// # Arguments
    ///
    /// * `copy_id` - The ID of the copy to be aborted.
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.abortCopyFromUrl")]
    pub async fn abort_copy(
        &self,
        copy_id: &str,
        options: Option<BlobClientAbortCopyOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "copy");
        query_builder.set_pair("copyid", copy_id);
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        request.insert_header("x-ms-copy-action", "abort");
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[204],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Requests a new lease on the specified blob.
    ///
    /// # Arguments
    ///
    /// * `duration` - Specifies the duration of the lease, in seconds, or negative one (-1) for a lease that never expires. A
    ///   non-infinite lease can be between 15 and 60 seconds.
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientAcquireLeaseResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientAcquireLeaseResult, BlobClientAcquireLeaseResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientAcquireLeaseResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(etag) = response.etag()? {
    ///         println!("etag: {:?}", etag);
    ///     }
    ///     if let Some(last_modified) = response.last_modified()? {
    ///         println!("last-modified: {:?}", last_modified);
    ///     }
    ///     if let Some(lease_id) = response.lease_id()? {
    ///         println!("x-ms-lease-id: {:?}", lease_id);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`etag`()](crate::generated::models::BlobClientAcquireLeaseResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientAcquireLeaseResultHeaders::last_modified) - last-modified
    /// * [`lease_id`()](crate::generated::models::BlobClientAcquireLeaseResultHeaders::lease_id) - x-ms-lease-id
    ///
    /// [`BlobClientAcquireLeaseResultHeaders`]: crate::generated::models::BlobClientAcquireLeaseResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.acquireLease")]
    pub async fn acquire_lease(
        &self,
        duration: i32,
        options: Option<BlobClientAcquireLeaseOptions<'_>>,
    ) -> Result<Response<BlobClientAcquireLeaseResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "lease");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        request.insert_header("x-ms-lease-action", "acquire");
        request.insert_header("x-ms-lease-duration", duration.to_string());
        if let Some(proposed_lease_id) = options.proposed_lease_id.as_ref() {
            request.insert_header("x-ms-proposed-lease-id", proposed_lease_id);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[201],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Ends a lease and ensures that another client can't acquire a new lease until the current lease period has expired.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientBreakLeaseResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientBreakLeaseResult, BlobClientBreakLeaseResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientBreakLeaseResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(etag) = response.etag()? {
    ///         println!("etag: {:?}", etag);
    ///     }
    ///     if let Some(last_modified) = response.last_modified()? {
    ///         println!("last-modified: {:?}", last_modified);
    ///     }
    ///     if let Some(lease_time) = response.lease_time()? {
    ///         println!("x-ms-lease-time: {:?}", lease_time);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`etag`()](crate::generated::models::BlobClientBreakLeaseResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientBreakLeaseResultHeaders::last_modified) - last-modified
    /// * [`lease_time`()](crate::generated::models::BlobClientBreakLeaseResultHeaders::lease_time) - x-ms-lease-time
    ///
    /// [`BlobClientBreakLeaseResultHeaders`]: crate::generated::models::BlobClientBreakLeaseResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.breakLease")]
    pub async fn break_lease(
        &self,
        options: Option<BlobClientBreakLeaseOptions<'_>>,
    ) -> Result<Response<BlobClientBreakLeaseResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "lease");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        request.insert_header("x-ms-lease-action", "break");
        if let Some(break_period) = options.break_period {
            request.insert_header("x-ms-lease-break-period", break_period.to_string());
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[202],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Change the ID of an existing lease.
    ///
    /// # Arguments
    ///
    /// * `lease_id` - A lease ID for the resource. The resource must have an active lease and the lease ID must match.
    /// * `proposed_lease_id` - The proposed lease ID for the lease.
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientChangeLeaseResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientChangeLeaseResult, BlobClientChangeLeaseResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientChangeLeaseResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(etag) = response.etag()? {
    ///         println!("etag: {:?}", etag);
    ///     }
    ///     if let Some(last_modified) = response.last_modified()? {
    ///         println!("last-modified: {:?}", last_modified);
    ///     }
    ///     if let Some(lease_id) = response.lease_id()? {
    ///         println!("x-ms-lease-id: {:?}", lease_id);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`etag`()](crate::generated::models::BlobClientChangeLeaseResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientChangeLeaseResultHeaders::last_modified) - last-modified
    /// * [`lease_id`()](crate::generated::models::BlobClientChangeLeaseResultHeaders::lease_id) - x-ms-lease-id
    ///
    /// [`BlobClientChangeLeaseResultHeaders`]: crate::generated::models::BlobClientChangeLeaseResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.changeLease")]
    pub async fn change_lease(
        &self,
        lease_id: String,
        proposed_lease_id: String,
        options: Option<BlobClientChangeLeaseOptions<'_>>,
    ) -> Result<Response<BlobClientChangeLeaseResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "lease");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        request.insert_header("x-ms-lease-action", "change");
        request.insert_header("x-ms-lease-id", lease_id);
        request.insert_header("x-ms-proposed-lease-id", proposed_lease_id);
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Creates a read-only snapshot of the specified blob.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientCreateSnapshotResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientCreateSnapshotResult, BlobClientCreateSnapshotResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientCreateSnapshotResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(etag) = response.etag()? {
    ///         println!("etag: {:?}", etag);
    ///     }
    ///     if let Some(last_modified) = response.last_modified()? {
    ///         println!("last-modified: {:?}", last_modified);
    ///     }
    ///     if let Some(is_server_encrypted) = response.is_server_encrypted()? {
    ///         println!("x-ms-request-server-encrypted: {:?}", is_server_encrypted);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`etag`()](crate::generated::models::BlobClientCreateSnapshotResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientCreateSnapshotResultHeaders::last_modified) - last-modified
    /// * [`is_server_encrypted`()](crate::generated::models::BlobClientCreateSnapshotResultHeaders::is_server_encrypted) - x-ms-request-server-encrypted
    /// * [`snapshot`()](crate::generated::models::BlobClientCreateSnapshotResultHeaders::snapshot) - x-ms-snapshot
    /// * [`version_id`()](crate::generated::models::BlobClientCreateSnapshotResultHeaders::version_id) - x-ms-version-id
    ///
    /// [`BlobClientCreateSnapshotResultHeaders`]: crate::generated::models::BlobClientCreateSnapshotResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.createSnapshot")]
    pub async fn create_snapshot(
        &self,
        options: Option<BlobClientCreateSnapshotOptions<'_>>,
    ) -> Result<Response<BlobClientCreateSnapshotResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "snapshot");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(encryption_algorithm) = options.encryption_algorithm.as_ref() {
            request.insert_header(
                "x-ms-encryption-algorithm",
                encryption_algorithm.to_string(),
            );
        }
        if let Some(encryption_key) = options.encryption_key.as_ref() {
            request.insert_header("x-ms-encryption-key", encryption_key);
        }
        if let Some(encryption_key_sha256) = options.encryption_key_sha256.as_ref() {
            request.insert_header("x-ms-encryption-key-sha256", encryption_key_sha256);
        }
        if let Some(encryption_scope) = options.encryption_scope.as_ref() {
            request.insert_header("x-ms-encryption-scope", encryption_scope);
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        if let Some(metadata) = options.metadata.as_ref() {
            for (k, v) in metadata {
                request.insert_header(format!("x-ms-meta-{k}"), v);
            }
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[201],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Deletes the specified blob. If blob soft delete is enabled, the blob is marked for deletion and can be recovered until
    /// the retention period expires.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.delete")]
    pub async fn delete(
        &self,
        options: Option<BlobClientDeleteOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        if let Some(blob_delete_type) = options.blob_delete_type.as_ref() {
            query_builder.set_pair("deletetype", blob_delete_type.as_ref());
        }
        if let Some(snapshot) = options.snapshot.as_ref() {
            query_builder.set_pair("snapshot", snapshot);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Delete);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(access_tier_if_modified_since) = options.access_tier_if_modified_since {
            request.insert_header(
                "x-ms-access-tier-if-modified-since",
                to_rfc7231(&access_tier_if_modified_since),
            );
        }
        if let Some(access_tier_if_unmodified_since) = options.access_tier_if_unmodified_since {
            request.insert_header(
                "x-ms-access-tier-if-unmodified-since",
                to_rfc7231(&access_tier_if_unmodified_since),
            );
        }
        if let Some(delete_snapshots) = options.delete_snapshots.as_ref() {
            request.insert_header("x-ms-delete-snapshots", delete_snapshots.to_string());
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[202],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Deletes the immutability policy on the specified blob.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.deleteImmutabilityPolicy")]
    pub async fn delete_immutability_policy(
        &self,
        options: Option<BlobClientDeleteImmutabilityPolicyOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "immutabilityPolicies");
        if let Some(snapshot) = options.snapshot.as_ref() {
            query_builder.set_pair("snapshot", snapshot);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Delete);
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Downloads the specified blob.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`AsyncResponse`](azure_core::http::AsyncResponse) implements the [`BlobClientDownloadInternalResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```ignore
    /// use azure_core::{Result, http::AsyncResponse};
    /// use azure_storage_blob::models::{BlobClientDownloadInternalResult, BlobClientDownloadInternalResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: AsyncResponse<BlobClientDownloadInternalResult> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(cache_control) = response.cache_control()? {
    ///         println!("cache-control: {:?}", cache_control);
    ///     }
    ///     if let Some(content_disposition) = response.content_disposition()? {
    ///         println!("content-disposition: {:?}", content_disposition);
    ///     }
    ///     if let Some(content_encoding) = response.content_encoding()? {
    ///         println!("content-encoding: {:?}", content_encoding);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`cache_control`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::cache_control) - cache-control
    /// * [`content_disposition`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::content_disposition) - content-disposition
    /// * [`content_encoding`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::content_encoding) - content-encoding
    /// * [`content_language`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::content_language) - content-language
    /// * [`content_length`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::content_length) - content-length
    /// * [`content_md5`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::content_md5) - content-md5
    /// * [`content_range`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::content_range) - content-range
    /// * [`etag`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::last_modified) - last-modified
    /// * [`blob_committed_block_count`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::blob_committed_block_count) - x-ms-blob-committed-block-count
    /// * [`blob_content_md5`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::blob_content_md5) - x-ms-blob-content-md5
    /// * [`is_sealed`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::is_sealed) - x-ms-blob-sealed
    /// * [`blob_sequence_number`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::blob_sequence_number) - x-ms-blob-sequence-number
    /// * [`blob_type`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::blob_type) - x-ms-blob-type
    /// * [`content_crc64`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::content_crc64) - x-ms-content-crc64
    /// * [`copy_completion_time`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::copy_completion_time) - x-ms-copy-completion-time
    /// * [`copy_id`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::copy_id) - x-ms-copy-id
    /// * [`copy_progress`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::copy_progress) - x-ms-copy-progress
    /// * [`copy_source`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::copy_source) - x-ms-copy-source
    /// * [`copy_status`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::copy_status) - x-ms-copy-status
    /// * [`copy_status_description`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::copy_status_description) - x-ms-copy-status-description
    /// * [`creation_time`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::creation_time) - x-ms-creation-time
    /// * [`encryption_key_sha256`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::encryption_key_sha256) - x-ms-encryption-key-sha256
    /// * [`encryption_scope`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::encryption_scope) - x-ms-encryption-scope
    /// * [`immutability_policy_mode`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::immutability_policy_mode) - x-ms-immutability-policy-mode
    /// * [`immutability_policy_expires_on`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::immutability_policy_expires_on) - x-ms-immutability-policy-until-date
    /// * [`is_current_version`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::is_current_version) - x-ms-is-current-version
    /// * [`last_accessed`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::last_accessed) - x-ms-last-access-time
    /// * [`duration`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::duration) - x-ms-lease-duration
    /// * [`lease_state`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::lease_state) - x-ms-lease-state
    /// * [`lease_status`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::lease_status) - x-ms-lease-status
    /// * [`legal_hold`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::legal_hold) - x-ms-legal-hold
    /// * [`metadata`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::metadata) - x-ms-meta
    /// * [`object_replication_rules`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::object_replication_rules) - x-ms-or
    /// * [`object_replication_policy_id`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::object_replication_policy_id) - x-ms-or-policy-id
    /// * [`is_server_encrypted`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::is_server_encrypted) - x-ms-server-encrypted
    /// * [`tag_count`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::tag_count) - x-ms-tag-count
    /// * [`version_id`()](crate::generated::models::BlobClientDownloadInternalResultHeaders::version_id) - x-ms-version-id
    ///
    /// [`BlobClientDownloadInternalResultHeaders`]: crate::generated::models::BlobClientDownloadInternalResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.download")]
    pub(crate) async fn download_internal(
        &self,
        options: Option<BlobClientDownloadInternalOptions<'_>>,
    ) -> Result<AsyncResponse<BlobClientDownloadInternalResult>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        if let Some(snapshot) = options.snapshot.as_ref() {
            query_builder.set_pair("snapshot", snapshot);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Get);
        request.insert_header("accept", "application/octet-stream");
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(range) = options.range.as_ref() {
            request.insert_header("range", range.to_string());
        }
        if let Some(encryption_algorithm) = options.encryption_algorithm.as_ref() {
            request.insert_header(
                "x-ms-encryption-algorithm",
                encryption_algorithm.to_string(),
            );
        }
        if let Some(encryption_key) = options.encryption_key.as_ref() {
            request.insert_header("x-ms-encryption-key", encryption_key);
        }
        if let Some(encryption_key_sha256) = options.encryption_key_sha256.as_ref() {
            request.insert_header("x-ms-encryption-key-sha256", encryption_key_sha256);
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        if let Some(range_get_content_crc64) = options.range_get_content_crc64 {
            request.insert_header(
                "x-ms-range-get-content-crc64",
                range_get_content_crc64.to_string(),
            );
        }
        if let Some(range_get_content_md5) = options.range_get_content_md5 {
            request.insert_header(
                "x-ms-range-get-content-md5",
                range_get_content_md5.to_string(),
            );
        }
        if let Some(structured_body_type) = options.structured_body_type.as_ref() {
            request.insert_header("x-ms-structured-body", structured_body_type);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .stream(
                &ctx,
                &mut request,
                Some(PipelineStreamOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200, 206],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Returns information about the storage account.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientGetAccountInfoResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientGetAccountInfoResult, BlobClientGetAccountInfoResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientGetAccountInfoResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(account_kind) = response.account_kind()? {
    ///         println!("x-ms-account-kind: {:?}", account_kind);
    ///     }
    ///     if let Some(is_hierarchical_namespace_enabled) = response.is_hierarchical_namespace_enabled()? {
    ///         println!("x-ms-is-hns-enabled: {:?}", is_hierarchical_namespace_enabled);
    ///     }
    ///     if let Some(sku_name) = response.sku_name()? {
    ///         println!("x-ms-sku-name: {:?}", sku_name);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`account_kind`()](crate::generated::models::BlobClientGetAccountInfoResultHeaders::account_kind) - x-ms-account-kind
    /// * [`is_hierarchical_namespace_enabled`()](crate::generated::models::BlobClientGetAccountInfoResultHeaders::is_hierarchical_namespace_enabled) - x-ms-is-hns-enabled
    /// * [`sku_name`()](crate::generated::models::BlobClientGetAccountInfoResultHeaders::sku_name) - x-ms-sku-name
    ///
    /// [`BlobClientGetAccountInfoResultHeaders`]: crate::generated::models::BlobClientGetAccountInfoResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.getAccountInfo")]
    pub async fn get_account_info(
        &self,
        options: Option<BlobClientGetAccountInfoOptions<'_>>,
    ) -> Result<Response<BlobClientGetAccountInfoResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder
            .append_pair("comp", "properties")
            .append_pair("restype", "account");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Get);
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Returns all user-defined metadata, standard HTTP properties, and system properties for the specified blob. It does not
    /// return the content of the blob.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientGetPropertiesResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientGetPropertiesResult, BlobClientGetPropertiesResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientGetPropertiesResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(cache_control) = response.cache_control()? {
    ///         println!("cache-control: {:?}", cache_control);
    ///     }
    ///     if let Some(content_disposition) = response.content_disposition()? {
    ///         println!("content-disposition: {:?}", content_disposition);
    ///     }
    ///     if let Some(content_encoding) = response.content_encoding()? {
    ///         println!("content-encoding: {:?}", content_encoding);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`cache_control`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::cache_control) - cache-control
    /// * [`content_disposition`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::content_disposition) - content-disposition
    /// * [`content_encoding`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::content_encoding) - content-encoding
    /// * [`content_language`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::content_language) - content-language
    /// * [`content_length`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::content_length) - content-length
    /// * [`content_md5`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::content_md5) - content-md5
    /// * [`content_type`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::content_type) - content-type
    /// * [`etag`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::last_modified) - last-modified
    /// * [`access_tier`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::access_tier) - x-ms-access-tier
    /// * [`access_tier_change_time`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::access_tier_change_time) - x-ms-access-tier-change-time
    /// * [`access_tier_inferred`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::access_tier_inferred) - x-ms-access-tier-inferred
    /// * [`archive_status`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::archive_status) - x-ms-archive-status
    /// * [`blob_committed_block_count`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::blob_committed_block_count) - x-ms-blob-committed-block-count
    /// * [`is_sealed`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::is_sealed) - x-ms-blob-sealed
    /// * [`blob_sequence_number`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::blob_sequence_number) - x-ms-blob-sequence-number
    /// * [`blob_type`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::blob_type) - x-ms-blob-type
    /// * [`copy_completion_time`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::copy_completion_time) - x-ms-copy-completion-time
    /// * [`destination_snapshot`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::destination_snapshot) - x-ms-copy-destination-snapshot
    /// * [`copy_id`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::copy_id) - x-ms-copy-id
    /// * [`copy_progress`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::copy_progress) - x-ms-copy-progress
    /// * [`copy_source`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::copy_source) - x-ms-copy-source
    /// * [`copy_status`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::copy_status) - x-ms-copy-status
    /// * [`copy_status_description`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::copy_status_description) - x-ms-copy-status-description
    /// * [`creation_time`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::creation_time) - x-ms-creation-time
    /// * [`encryption_key_sha256`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::encryption_key_sha256) - x-ms-encryption-key-sha256
    /// * [`encryption_scope`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::encryption_scope) - x-ms-encryption-scope
    /// * [`expires_on`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::expires_on) - x-ms-expiry-time
    /// * [`immutability_policy_mode`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::immutability_policy_mode) - x-ms-immutability-policy-mode
    /// * [`immutability_policy_expires_on`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::immutability_policy_expires_on) - x-ms-immutability-policy-until-date
    /// * [`is_incremental_copy`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::is_incremental_copy) - x-ms-incremental-copy
    /// * [`is_current_version`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::is_current_version) - x-ms-is-current-version
    /// * [`last_accessed`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::last_accessed) - x-ms-last-access-time
    /// * [`duration`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::duration) - x-ms-lease-duration
    /// * [`lease_state`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::lease_state) - x-ms-lease-state
    /// * [`lease_status`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::lease_status) - x-ms-lease-status
    /// * [`legal_hold`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::legal_hold) - x-ms-legal-hold
    /// * [`metadata`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::metadata) - x-ms-meta
    /// * [`object_replication_rules`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::object_replication_rules) - x-ms-or
    /// * [`object_replication_policy_id`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::object_replication_policy_id) - x-ms-or-policy-id
    /// * [`rehydrate_priority`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::rehydrate_priority) - x-ms-rehydrate-priority
    /// * [`is_server_encrypted`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::is_server_encrypted) - x-ms-server-encrypted
    /// * [`tag_count`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::tag_count) - x-ms-tag-count
    /// * [`version_id`()](crate::generated::models::BlobClientGetPropertiesResultHeaders::version_id) - x-ms-version-id
    ///
    /// [`BlobClientGetPropertiesResultHeaders`]: crate::generated::models::BlobClientGetPropertiesResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.getProperties")]
    pub async fn get_properties(
        &self,
        options: Option<BlobClientGetPropertiesOptions<'_>>,
    ) -> Result<Response<BlobClientGetPropertiesResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        if let Some(snapshot) = options.snapshot.as_ref() {
            query_builder.set_pair("snapshot", snapshot);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Head);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(encryption_algorithm) = options.encryption_algorithm.as_ref() {
            request.insert_header(
                "x-ms-encryption-algorithm",
                encryption_algorithm.to_string(),
            );
        }
        if let Some(encryption_key) = options.encryption_key.as_ref() {
            request.insert_header("x-ms-encryption-key", encryption_key);
        }
        if let Some(encryption_key_sha256) = options.encryption_key_sha256.as_ref() {
            request.insert_header("x-ms-encryption-key-sha256", encryption_key_sha256);
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Gets the tags of the specified blob.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.getTags")]
    pub async fn get_tags(
        &self,
        options: Option<BlobClientGetTagsOptions<'_>>,
    ) -> Result<Response<BlobTags, XmlFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "tags");
        if let Some(snapshot) = options.snapshot.as_ref() {
            query_builder.set_pair("snapshot", snapshot);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Get);
        request.insert_header("accept", "application/xml");
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("x-ms-blob-if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header(
                "x-ms-blob-if-modified-since",
                to_rfc7231(&if_modified_since),
            );
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("x-ms-blob-if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header(
                "x-ms-blob-if-unmodified-since",
                to_rfc7231(&if_unmodified_since),
            );
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Frees the lease if it's no longer needed, so that another client can immediately acquire a lease against the blob.
    ///
    /// # Arguments
    ///
    /// * `lease_id` - A lease ID for the resource. The resource must have an active lease and the lease ID must match.
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientReleaseLeaseResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientReleaseLeaseResult, BlobClientReleaseLeaseResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientReleaseLeaseResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(etag) = response.etag()? {
    ///         println!("etag: {:?}", etag);
    ///     }
    ///     if let Some(last_modified) = response.last_modified()? {
    ///         println!("last-modified: {:?}", last_modified);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`etag`()](crate::generated::models::BlobClientReleaseLeaseResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientReleaseLeaseResultHeaders::last_modified) - last-modified
    ///
    /// [`BlobClientReleaseLeaseResultHeaders`]: crate::generated::models::BlobClientReleaseLeaseResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.releaseLease")]
    pub async fn release_lease(
        &self,
        lease_id: String,
        options: Option<BlobClientReleaseLeaseOptions<'_>>,
    ) -> Result<Response<BlobClientReleaseLeaseResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "lease");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        request.insert_header("x-ms-lease-action", "release");
        request.insert_header("x-ms-lease-id", lease_id);
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Renews an existing lease.
    ///
    /// # Arguments
    ///
    /// * `lease_id` - A lease ID for the resource. The resource must have an active lease and the lease ID must match.
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientRenewLeaseResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientRenewLeaseResult, BlobClientRenewLeaseResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientRenewLeaseResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(etag) = response.etag()? {
    ///         println!("etag: {:?}", etag);
    ///     }
    ///     if let Some(last_modified) = response.last_modified()? {
    ///         println!("last-modified: {:?}", last_modified);
    ///     }
    ///     if let Some(lease_id) = response.lease_id()? {
    ///         println!("x-ms-lease-id: {:?}", lease_id);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`etag`()](crate::generated::models::BlobClientRenewLeaseResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientRenewLeaseResultHeaders::last_modified) - last-modified
    /// * [`lease_id`()](crate::generated::models::BlobClientRenewLeaseResultHeaders::lease_id) - x-ms-lease-id
    ///
    /// [`BlobClientRenewLeaseResultHeaders`]: crate::generated::models::BlobClientRenewLeaseResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.renewLease")]
    pub async fn renew_lease(
        &self,
        lease_id: String,
        options: Option<BlobClientRenewLeaseOptions<'_>>,
    ) -> Result<Response<BlobClientRenewLeaseResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "lease");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        request.insert_header("x-ms-lease-action", "renew");
        request.insert_header("x-ms-lease-id", lease_id);
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Set the immutability policy on the specified blob.
    ///
    /// # Arguments
    ///
    /// * `expiry` - The date-time that indicates the time at which the blob immutability policy will expire.
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.setImmutabilityPolicy")]
    pub async fn set_immutability_policy(
        &self,
        expiry: &OffsetDateTime,
        options: Option<BlobClientSetImmutabilityPolicyOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "immutabilityPolicies");
        if let Some(snapshot) = options.snapshot.as_ref() {
            query_builder.set_pair("snapshot", snapshot);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(immutability_policy_mode) = options.immutability_policy_mode.as_ref() {
            request.insert_header(
                "x-ms-immutability-policy-mode",
                immutability_policy_mode.to_string(),
            );
        }
        request.insert_header("x-ms-immutability-policy-until-date", to_rfc7231(expiry));
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Sets a legal hold on the specified blob.
    ///
    /// # Arguments
    ///
    /// * `legal_hold` - Indicates whether the blob has a legal hold.
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.setLegalHold")]
    pub async fn set_legal_hold(
        &self,
        legal_hold: bool,
        options: Option<BlobClientSetLegalHoldOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "legalhold");
        if let Some(snapshot) = options.snapshot.as_ref() {
            query_builder.set_pair("snapshot", snapshot);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        request.insert_header("x-ms-legal-hold", legal_hold.to_string());
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Sets user-defined metadata for the specified blob.
    ///
    /// # Arguments
    ///
    /// * `metadata` - The metadata headers.
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.setMetadata")]
    pub async fn set_metadata(
        &self,
        metadata: &HashMap<String, String>,
        options: Option<BlobClientSetMetadataOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "metadata");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(encryption_algorithm) = options.encryption_algorithm.as_ref() {
            request.insert_header(
                "x-ms-encryption-algorithm",
                encryption_algorithm.to_string(),
            );
        }
        if let Some(encryption_key) = options.encryption_key.as_ref() {
            request.insert_header("x-ms-encryption-key", encryption_key);
        }
        if let Some(encryption_key_sha256) = options.encryption_key_sha256.as_ref() {
            request.insert_header("x-ms-encryption-key-sha256", encryption_key_sha256);
        }
        if let Some(encryption_scope) = options.encryption_scope.as_ref() {
            request.insert_header("x-ms-encryption-scope", encryption_scope);
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        for (k, v) in metadata {
            request.insert_header(format!("x-ms-meta-{k}"), v);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Sets system properties on the specified blob.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.setProperties")]
    pub async fn set_properties(
        &self,
        options: Option<BlobClientSetPropertiesOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "properties");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(blob_cache_control) = options.blob_cache_control.as_ref() {
            request.insert_header("x-ms-blob-cache-control", blob_cache_control);
        }
        if let Some(blob_content_disposition) = options.blob_content_disposition.as_ref() {
            request.insert_header("x-ms-blob-content-disposition", blob_content_disposition);
        }
        if let Some(blob_content_encoding) = options.blob_content_encoding.as_ref() {
            request.insert_header("x-ms-blob-content-encoding", blob_content_encoding);
        }
        if let Some(blob_content_language) = options.blob_content_language.as_ref() {
            request.insert_header("x-ms-blob-content-language", blob_content_language);
        }
        if let Some(blob_content_md5) = options.blob_content_md5 {
            request.insert_header("x-ms-blob-content-md5", base64::encode(blob_content_md5));
        }
        if let Some(blob_content_type) = options.blob_content_type.as_ref() {
            request.insert_header("x-ms-blob-content-type", blob_content_type);
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Sets the tags of the specified blob.
    ///
    /// # Arguments
    ///
    /// * `tags` - The blob tags.
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.setTags")]
    pub async fn set_tags(
        &self,
        tags: RequestContent<BlobTags, XmlFormat>,
        options: Option<BlobClientSetTagsOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "tags");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(transactional_content_md5) = options.transactional_content_md5 {
            request.insert_header("content-md5", base64::encode(transactional_content_md5));
        }
        request.insert_header("content-type", "application/xml");
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("x-ms-blob-if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header(
                "x-ms-blob-if-modified-since",
                to_rfc7231(&if_modified_since),
            );
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("x-ms-blob-if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header(
                "x-ms-blob-if-unmodified-since",
                to_rfc7231(&if_unmodified_since),
            );
        }
        if let Some(transactional_content_crc64) = options.transactional_content_crc64 {
            request.insert_header(
                "x-ms-content-crc64",
                base64::encode(transactional_content_crc64),
            );
        }
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        request.insert_header("x-ms-version", &self.version);
        request.set_body(tags);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[204],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Sets the tier of the specified blob.
    ///
    /// # Arguments
    ///
    /// * `tier` - Indicates the tier to be set on the blob.
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.setTier")]
    pub async fn set_tier(
        &self,
        tier: AccessTier,
        options: Option<BlobClientSetTierOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "tier");
        if let Some(snapshot) = options.snapshot.as_ref() {
            query_builder.set_pair("snapshot", snapshot);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        if let Some(version_id) = options.version_id.as_ref() {
            query_builder.set_pair("versionid", version_id);
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        request.insert_header("x-ms-access-tier", tier.to_string());
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        if let Some(rehydrate_priority) = options.rehydrate_priority.as_ref() {
            request.insert_header("x-ms-rehydrate-priority", rehydrate_priority.to_string());
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200, 202],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Starts an asynchronous copy from a source URL to a destination blob.
    ///
    /// # Arguments
    ///
    /// * `copy_source` - Specifies the name of the source URL for the copy operation. The value should be URL-encoded as it would
    ///   appear in a request URI.
    /// * `options` - Optional parameters for the request.
    ///
    /// ## Response Headers
    ///
    /// The returned [`Response`](azure_core::http::Response) implements the [`BlobClientStartCopyFromUrlResultHeaders`] trait, which provides
    /// access to response headers. For example:
    ///
    /// ```no_run
    /// use azure_core::{Result, http::{Response, NoFormat}};
    /// use azure_storage_blob::models::{BlobClientStartCopyFromUrlResult, BlobClientStartCopyFromUrlResultHeaders};
    /// async fn example() -> Result<()> {
    ///     let response: Response<BlobClientStartCopyFromUrlResult, NoFormat> = unimplemented!();
    ///     // Access response headers
    ///     if let Some(etag) = response.etag()? {
    ///         println!("etag: {:?}", etag);
    ///     }
    ///     if let Some(last_modified) = response.last_modified()? {
    ///         println!("last-modified: {:?}", last_modified);
    ///     }
    ///     if let Some(copy_id) = response.copy_id()? {
    ///         println!("x-ms-copy-id: {:?}", copy_id);
    ///     }
    ///     Ok(())
    /// }
    /// ```
    ///
    /// ### Available headers
    /// * [`etag`()](crate::generated::models::BlobClientStartCopyFromUrlResultHeaders::etag) - etag
    /// * [`last_modified`()](crate::generated::models::BlobClientStartCopyFromUrlResultHeaders::last_modified) - last-modified
    /// * [`copy_id`()](crate::generated::models::BlobClientStartCopyFromUrlResultHeaders::copy_id) - x-ms-copy-id
    /// * [`copy_status`()](crate::generated::models::BlobClientStartCopyFromUrlResultHeaders::copy_status) - x-ms-copy-status
    /// * [`version_id`()](crate::generated::models::BlobClientStartCopyFromUrlResultHeaders::version_id) - x-ms-version-id
    ///
    /// [`BlobClientStartCopyFromUrlResultHeaders`]: crate::generated::models::BlobClientStartCopyFromUrlResultHeaders
    #[tracing::function("Storage.Blob.BlobClient.startCopyFromUrl")]
    pub async fn start_copy_from_url(
        &self,
        copy_source: String,
        options: Option<BlobClientStartCopyFromUrlOptions<'_>>,
    ) -> Result<Response<BlobClientStartCopyFromUrlResult, NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        if let Some(if_match) = options.if_match.as_ref() {
            request.insert_header("if-match", if_match.to_string());
        }
        if let Some(if_modified_since) = options.if_modified_since {
            request.insert_header("if-modified-since", to_rfc7231(&if_modified_since));
        }
        if let Some(if_none_match) = options.if_none_match.as_ref() {
            request.insert_header("if-none-match", if_none_match.to_string());
        }
        if let Some(if_unmodified_since) = options.if_unmodified_since {
            request.insert_header("if-unmodified-since", to_rfc7231(&if_unmodified_since));
        }
        if let Some(tier) = options.tier.as_ref() {
            request.insert_header("x-ms-access-tier", tier.to_string());
        }
        request.insert_header("x-ms-copy-source", copy_source);
        if let Some(if_tags) = options.if_tags.as_ref() {
            request.insert_header("x-ms-if-tags", if_tags);
        }
        if let Some(immutability_policy_mode) = options.immutability_policy_mode.as_ref() {
            request.insert_header(
                "x-ms-immutability-policy-mode",
                immutability_policy_mode.to_string(),
            );
        }
        if let Some(immutability_policy_expiry) = options.immutability_policy_expiry {
            request.insert_header(
                "x-ms-immutability-policy-until-date",
                to_rfc7231(&immutability_policy_expiry),
            );
        }
        if let Some(lease_id) = options.lease_id.as_ref() {
            request.insert_header("x-ms-lease-id", lease_id);
        }
        if let Some(legal_hold) = options.legal_hold {
            request.insert_header("x-ms-legal-hold", legal_hold.to_string());
        }
        if let Some(metadata) = options.metadata.as_ref() {
            for (k, v) in metadata {
                request.insert_header(format!("x-ms-meta-{k}"), v);
            }
        }
        if let Some(rehydrate_priority) = options.rehydrate_priority.as_ref() {
            request.insert_header("x-ms-rehydrate-priority", rehydrate_priority.to_string());
        }
        if let Some(seal_blob) = options.seal_blob {
            request.insert_header("x-ms-seal-blob", seal_blob.to_string());
        }
        if let Some(source_if_match) = options.source_if_match.as_ref() {
            request.insert_header("x-ms-source-if-match", source_if_match.to_string());
        }
        if let Some(source_if_modified_since) = options.source_if_modified_since {
            request.insert_header(
                "x-ms-source-if-modified-since",
                to_rfc7231(&source_if_modified_since),
            );
        }
        if let Some(source_if_none_match) = options.source_if_none_match.as_ref() {
            request.insert_header(
                "x-ms-source-if-none-match",
                source_if_none_match.to_string(),
            );
        }
        if let Some(source_if_tags) = options.source_if_tags.as_ref() {
            request.insert_header("x-ms-source-if-tags", source_if_tags);
        }
        if let Some(source_if_unmodified_since) = options.source_if_unmodified_since {
            request.insert_header(
                "x-ms-source-if-unmodified-since",
                to_rfc7231(&source_if_unmodified_since),
            );
        }
        if let Some(blob_tags_string) = options.blob_tags_string.as_ref() {
            request.insert_header("x-ms-tags", blob_tags_string);
        }
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[202],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Undelete the specified previously soft deleted blob.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Blob.BlobClient.undelete")]
    pub async fn undelete(
        &self,
        options: Option<BlobClientUndeleteOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder.append_pair("comp", "undelete");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }
}

/// Default value for [`BlobClientOptions::version`].
pub(crate) const DEFAULT_VERSION: &str = "2026-04-06";

impl Default for BlobClientOptions {
    fn default() -> Self {
        Self {
            client_options: ClientOptions::default(),
            version: String::from(DEFAULT_VERSION),
        }
    }
}