AWS SDK

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

// Loading the partition JSON is expensive since it involves many regex compilations,

// so cache the result so that it only need to be paid for the first constructed client.

pub(crate) static DEFAULT_PARTITION_RESOLVER: std::sync::LazyLock<crate::endpoint_lib::partition::PartitionResolver> = std::sync::LazyLock::new(

    || match std::env::var("SMITHY_CLIENT_SDK_CUSTOM_PARTITION") {

        Ok(partitions) => {

            ::tracing::debug!("loading custom partitions located at {partitions}");

        self,

        client: &crate::Client,

    ) -> ::std::result::Result<

        crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.associate_access_grants_identity_center();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `AssociateAccessGrantsIdentityCenter`.

///

/// <p>Associate your S3 Access Grants instance with an Amazon Web Services IAM Identity Center instance. Use this action if you want to create access grants for users or groups from your corporate identity directory. First, you must add your corporate identity directory to Amazon Web Services IAM Identity Center. Then, you can associate this IAM Identity Center instance with your S3 Access Grants instance.</p>

/// <dl>

/// <dt>

/// Permissions

    > for AssociateAccessGrantsIdentityCenterFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterOutput,

            crate::operation::associate_access_grants_identity_center::AssociateAccessGrantsIdentityCenterError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl AssociateAccessGrantsIdentityCenterFluentBuilder {

    /// Creates a new `AssociateAccessGrantsIdentityCenterFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

    ) -> ::std::result::Result<

        crate::operation::create_access_grant::CreateAccessGrantOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_access_grant::CreateAccessGrantError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.create_access_grant();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `CreateAccessGrant`.

///

/// <p>Creates an access grant that gives a grantee access to your S3 data. The grantee can be an IAM user or role or a directory user, or group. Before you can create a grant, you must have an S3 Access Grants instance in the same Region as the S3 data. You can create an S3 Access Grants instance using the <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessGrantsInstance.html">CreateAccessGrantsInstance</a>. You must also have registered at least one S3 data location in your S3 Access Grants instance using <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessGrantsLocation.html">CreateAccessGrantsLocation</a>.</p>

/// <dl>

/// <dt>

/// Permissions

/// </dt>

/// <dd>

    > for CreateAccessGrantFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::create_access_grant::CreateAccessGrantOutput,

            crate::operation::create_access_grant::CreateAccessGrantError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateAccessGrantFluentBuilder {

    /// Creates a new `CreateAccessGrantFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

        self,

        client: &crate::Client,

    ) -> ::std::result::Result<

        crate::operation::create_access_grants_instance::CreateAccessGrantsInstanceOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_access_grants_instance::CreateAccessGrantsInstanceError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.create_access_grants_instance();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `CreateAccessGrantsInstance`.

///

/// <p>Creates an S3 Access Grants instance, which serves as a logical grouping for access grants. You can create one S3 Access Grants instance per Region per account.</p>

/// <dl>

/// <dt>

/// Permissions

    > for CreateAccessGrantsInstanceFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::create_access_grants_instance::CreateAccessGrantsInstanceOutput,

            crate::operation::create_access_grants_instance::CreateAccessGrantsInstanceError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateAccessGrantsInstanceFluentBuilder {

    /// Creates a new `CreateAccessGrantsInstanceFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

    }

}

/// Fluent builder constructing a request to `CreateAccessGrantsLocation`.

///

/// <p>The S3 data location that you would like to register in your S3 Access Grants instance. Your S3 data must be in the same Region as your S3 Access Grants instance. The location can be one of the following:</p>

/// <ul>

/// <li>

/// <p>The default S3 location <code>s3://</code></p></li>

/// <li>

/// <p>A bucket - <code>S3://<bucket-name></bucket-name></code></p></li>

/// <li>

/// <p>A bucket and prefix - <code>S3://<bucket-name>

/// /

/// <prefix></prefix>

/// </bucket-name></code></p></li>

/// </ul>

/// <p>When you register a location, you must include the IAM role that has permission to manage the S3 location that you are registering. Give S3 Access Grants permission to assume this role <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-grants-location.html">using a policy</a>. S3 Access Grants assumes this role to manage access to the location and to vend temporary credentials to grantees or client applications.</p>

/// <dl>

/// <dt>

/// Permissions

    > for CreateAccessGrantsLocationFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::create_access_grants_location::CreateAccessGrantsLocationOutput,

            crate::operation::create_access_grants_location::CreateAccessGrantsLocationError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateAccessGrantsLocationFluentBuilder {

    /// Creates a new `CreateAccessGrantsLocationFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

    pub account_id: ::std::option::Option<::std::string::String>,

    /// <p>The name you want to assign to this access point.</p>

    /// <p>For directory buckets, the access point name must consist of a base name that you provide and suffix that includes the <code>ZoneID</code> (Amazon Web Services Availability Zone or Local Zone) of your bucket location, followed by <code>--xa-s3</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p>

    pub name: ::std::option::Option<::std::string::String>,

    /// <p>The name of the bucket that you want to associate this access point with.</p>

    /// <p>For using this parameter with Amazon S3 on Outposts with the REST API, you must specify the name and the x-amz-outpost-id as well.</p>

    /// <p>For using this parameter with S3 on Outposts with the Amazon Web Services SDK and CLI, you must specify the ARN of the bucket accessed in the format <code>arn:aws:s3-outposts:<region>

    /// :

    /// <account-id>

    /// :outpost/

    /// <outpost-id>

    /// /bucket/

    /// <my-bucket-name></my-bucket-name>

    /// </outpost-id>

    /// </account-id>

    /// </region></code>. For example, to access the bucket <code>reports</code> through Outpost <code>my-outpost</code> owned by account <code>123456789012</code> in Region <code>us-west-2</code>, use the URL encoding of <code>arn:aws:s3-outposts:us-west-2:123456789012:outpost/my-outpost/bucket/reports</code>. The value must be URL encoded.</p>

    pub bucket: ::std::option::Option<::std::string::String>,

    /// <p>If you include this field, Amazon S3 restricts access to this access point to requests from the specified virtual private cloud (VPC).</p><note>

    /// <p>This is required for creating an access point for Amazon S3 on Outposts buckets.</p>

    /// </note>

    }

}

/// A builder for [`CreateAccessPointInput`](crate::operation::create_access_point::CreateAccessPointInput).

#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

#[non_exhaustive]

pub struct CreateAccessPointInputBuilder {

    pub(crate) account_id: ::std::option::Option<::std::string::String>,

    pub(crate) name: ::std::option::Option<::std::string::String>,

    pub(crate) bucket: ::std::option::Option<::std::string::String>,

    pub(crate) vpc_configuration: ::std::option::Option<crate::types::VpcConfiguration>,

    pub(crate) public_access_block_configuration: ::std::option::Option<crate::types::PublicAccessBlockConfiguration>,

    pub(crate) bucket_account_id: ::std::option::Option<::std::string::String>,

    pub(crate) scope: ::std::option::Option<crate::types::Scope>,

    pub(crate) tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,

}

impl CreateAccessPointInputBuilder {

    /// <p>The Amazon Web Services account ID for the account that owns the specified access point.</p>

    /// This field is required.

    pub fn account_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {

    }

    /// <p>The Amazon Web Services account ID associated with the S3 bucket associated with this access point.</p>

    /// <p>For same account access point when your bucket and access point belong to the same account owner, the <code>BucketAccountId</code> is not required. For cross-account access point when your bucket and access point are not in the same account, the <code>BucketAccountId</code> is required.</p>

    pub fn get_bucket_account_id(&self) -> &::std::option::Option<::std::string::String> {

        &self.bucket_account_id

    }

    /// <p>For directory buckets, you can filter access control to specific prefixes, API operations, or a combination of both. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>

    /// <p>Scope is only supported for access points attached to directory buckets.</p>

    /// </note>

    pub fn scope(mut self, input: crate::types::Scope) -> Self {

        self.scope = ::std::option::Option::Some(input);

        self

    }

    /// <p>For directory buckets, you can filter access control to specific prefixes, API operations, or a combination of both. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>

    /// <p>Scope is only supported for access points attached to directory buckets.</p>

    /// </note>

    pub fn set_scope(mut self, input: ::std::option::Option<crate::types::Scope>) -> Self {

        self.scope = input;

        self

    }

            bucket: self.bucket,

            vpc_configuration: self.vpc_configuration,

            public_access_block_configuration: self.public_access_block_configuration,

            bucket_account_id: self.bucket_account_id,

            scope: self.scope,

            tags: self.tags,

        })

    }

}

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_access_point::CreateAccessPointError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.create_access_point();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `CreateAccessPoint`.

///

/// <p>Creates an access point and associates it to a specified bucket. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points.html">Managing access to shared datasets with access points</a> or <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <p>To create an access point and attach it to a volume on an Amazon FSx file system, see <a href="https://docs.aws.amazon.com/fsx/latest/APIReference/API_CreateAndAttachS3AccessPoint.html">CreateAndAttachS3AccessPoint</a> in the <i>Amazon FSx API Reference</i>.</p>

/// <p></p><note>

/// <p>S3 on Outposts only supports VPC-style access points.</p>

/// <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html"> Accessing Amazon S3 on Outposts using virtual private cloud (VPC) only access points</a> in the <i>Amazon S3 User Guide</i>.</p>

/// </note>

/// <p>All Amazon S3 on Outposts REST API requests for this action require an additional parameter of <code>x-amz-outpost-id</code> to be passed with the request. In addition, you must use an S3 on Outposts endpoint hostname prefix instead of <code>s3-control</code>. For an example of the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and the <code>x-amz-outpost-id</code> derived by using the access point ARN, see the <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateAccessPoint.html#API_control_CreateAccessPoint_Examples">Examples</a> section.</p>

/// <p></p>

    > for CreateAccessPointFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::create_access_point::CreateAccessPointOutput,

            crate::operation::create_access_point::CreateAccessPointError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateAccessPointFluentBuilder {

    /// Creates a new `CreateAccessPointFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

    /// <p>The Amazon Web Services account ID associated with the S3 bucket associated with this access point.</p>

    /// <p>For same account access point when your bucket and access point belong to the same account owner, the <code>BucketAccountId</code> is not required. For cross-account access point when your bucket and access point are not in the same account, the <code>BucketAccountId</code> is required.</p>

    pub fn get_bucket_account_id(&self) -> &::std::option::Option<::std::string::String> {

        self.inner.get_bucket_account_id()

    }

    /// <p>For directory buckets, you can filter access control to specific prefixes, API operations, or a combination of both. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>

    /// <p>Scope is only supported for access points attached to directory buckets.</p>

    /// </note>

    pub fn scope(mut self, input: crate::types::Scope) -> Self {

        self.inner = self.inner.scope(input);

        self

    }

    /// <p>For directory buckets, you can filter access control to specific prefixes, API operations, or a combination of both. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>

    /// <p>Scope is only supported for access points attached to directory buckets.</p>

    /// </note>

    pub fn set_scope(mut self, input: ::std::option::Option<crate::types::Scope>) -> Self {

        self.inner = self.inner.set_scope(input);

        self

    }

    /// <p>For directory buckets, you can filter access control to specific prefixes, API operations, or a combination of both. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-directory-buckets.html">Managing access to shared datasets in directory buckets with access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>

    /// Sends a request with this input using the given client.

    pub async fn send_with(

        self,

        client: &crate::Client,

    ) -> ::std::result::Result<

        crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.create_access_point_for_object_lambda();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `CreateAccessPointForObjectLambda`.

///

/// <note>

/// <p>This operation is not supported by directory buckets.</p>

    > for CreateAccessPointForObjectLambdaFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaOutput,

            crate::operation::create_access_point_for_object_lambda::CreateAccessPointForObjectLambdaError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateAccessPointForObjectLambdaFluentBuilder {

    /// Creates a new `CreateAccessPointForObjectLambdaFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

        let mut fluent_builder = client.create_job();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `CreateJob`.

///

/// <p>This operation creates an S3 Batch Operations job.</p>

/// <p>You can use S3 Batch Operations to perform large-scale batch actions on Amazon S3 objects. Batch Operations can run a single action on lists of Amazon S3 objects that you specify. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops.html">S3 Batch Operations</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <dl>

/// <dt>

/// Permissions

/// </dt>

/// <dd>

/// <p>For information about permissions required to use the Batch Operations, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-iam-role-policies.html">Granting permissions for S3 Batch Operations</a> in the <i>Amazon S3 User Guide</i>.</p>

/// </dd>

/// </dl>

/// <p></p>

/// <p>Related actions include:</p>

/// <ul>

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<crate::operation::create_job::CreateJobOutput, crate::operation::create_job::CreateJobError>,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateJobFluentBuilder {

    /// Creates a new `CreateJobFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

            config_override: ::std::option::Option::None,

        }

    }

    /// Access the CreateJob as a reference.

    pub fn as_input(&self) -> &crate::operation::create_job::builders::CreateJobInputBuilder {

        &self.inner

    ) -> ::std::result::Result<

        crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.create_multi_region_access_point();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

/// Fluent builder constructing a request to `CreateMultiRegionAccessPoint`.

///

/// <note>

/// <p>This operation is not supported by directory buckets.</p>

/// </note>

/// <p>Creates a Multi-Region Access Point and associates it with the specified buckets. For more information about creating Multi-Region Access Points, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingMultiRegionAccessPoints.html">Creating Multi-Region Access Points</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <p>This action will always be routed to the US West (Oregon) Region. For more information about the restrictions around working with Multi-Region Access Points, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/MultiRegionAccessPointRestrictions.html">Multi-Region Access Point restrictions and limitations</a> in the <i>Amazon S3 User Guide</i>.</p>

/// <p>This request is asynchronous, meaning that you might receive a response before the command has completed. When this request provides a response, it provides a token that you can use to monitor the status of the request with <code>DescribeMultiRegionAccessPointOperation</code>.</p>

    > for CreateMultiRegionAccessPointFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointOutput,

            crate::operation::create_multi_region_access_point::CreateMultiRegionAccessPointError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateMultiRegionAccessPointFluentBuilder {

    /// Creates a new `CreateMultiRegionAccessPointFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

pub use crate::operation::create_storage_lens_group::_create_storage_lens_group_input::CreateStorageLensGroupInputBuilder;

pub use crate::operation::create_storage_lens_group::_create_storage_lens_group_output::CreateStorageLensGroupOutputBuilder;

impl crate::operation::create_storage_lens_group::builders::CreateStorageLensGroupInputBuilder {

    /// Sends a request with this input using the given client.

    pub async fn send_with(

        self,

        client: &crate::Client,

    ) -> ::std::result::Result<

        crate::operation::create_storage_lens_group::CreateStorageLensGroupOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::create_storage_lens_group::CreateStorageLensGroupError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > for CreateStorageLensGroupFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::create_storage_lens_group::CreateStorageLensGroupOutput,

            crate::operation::create_storage_lens_group::CreateStorageLensGroupError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl CreateStorageLensGroupFluentBuilder {

    /// Creates a new `CreateStorageLensGroupFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),

pub use crate::operation::delete_access_grant::_delete_access_grant_output::DeleteAccessGrantOutputBuilder;

impl crate::operation::delete_access_grant::builders::DeleteAccessGrantInputBuilder {

    /// Sends a request with this input using the given client.

    pub async fn send_with(

        self,

        client: &crate::Client,

    ) -> ::std::result::Result<

        crate::operation::delete_access_grant::DeleteAccessGrantOutput,

        ::aws_smithy_runtime_api::client::result::SdkError<

            crate::operation::delete_access_grant::DeleteAccessGrantError,

            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,

        >,

    > {

        let mut fluent_builder = client.delete_access_grant();

        fluent_builder.inner = self;

        fluent_builder.send().await

    }

}

    > for DeleteAccessGrantFluentBuilder

{

    fn send(

        self,

        config_override: crate::config::Builder,

    ) -> crate::client::customize::internal::BoxFuture<

        crate::client::customize::internal::SendResult<

            crate::operation::delete_access_grant::DeleteAccessGrantOutput,

            crate::operation::delete_access_grant::DeleteAccessGrantError,

        >,

    > {

        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })

    }

}

impl DeleteAccessGrantFluentBuilder {

    /// Creates a new `DeleteAccessGrantFluentBuilder`.

    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {

        Self {

            handle,

            inner: ::std::default::Default::default(),