/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include namespace Aws { namespace S3Control { /** *

Amazon Web Services S3 Control provides access to Amazon S3 control plane * actions.

*/ class AWS_S3CONTROL_API S3ControlClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef S3ControlClientConfiguration ClientConfigurationType; typedef S3ControlEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ S3ControlClient(const Aws::S3Control::S3ControlClientConfiguration& clientConfiguration = Aws::S3Control::S3ControlClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ S3ControlClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::S3Control::S3ControlClientConfiguration& clientConfiguration = Aws::S3Control::S3ControlClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ S3ControlClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::S3Control::S3ControlClientConfiguration& clientConfiguration = Aws::S3Control::S3ControlClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ S3ControlClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ S3ControlClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ S3ControlClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~S3ControlClient(); /** *

Creates an access point and associates it with the specified bucket. For more * information, see Managing * Data Access with Amazon S3 Access Points in the Amazon S3 User * Guide.

S3 on Outposts only supports VPC-style access * points.

For more information, see * Accessing Amazon S3 on Outposts using virtual private cloud (VPC) only access * points in the Amazon S3 User Guide.

All Amazon S3 on * Outposts REST API requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following actions are related to * CreateAccessPoint:

See Also:

AWS * API Reference

*/ virtual Model::CreateAccessPointOutcome CreateAccessPoint(const Model::CreateAccessPointRequest& request) const; /** * A Callable wrapper for CreateAccessPoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAccessPointOutcomeCallable CreateAccessPointCallable(const CreateAccessPointRequestT& request) const { return SubmitCallable(&S3ControlClient::CreateAccessPoint, request); } /** * An Async wrapper for CreateAccessPoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAccessPointAsync(const CreateAccessPointRequestT& request, const CreateAccessPointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::CreateAccessPoint, request, handler, context); } /** *

Creates an Object Lambda Access Point. For more information, see Transforming * objects with Object Lambda Access Points in the Amazon S3 User * Guide.

The following actions are related to * CreateAccessPointForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::CreateAccessPointForObjectLambdaOutcome CreateAccessPointForObjectLambda(const Model::CreateAccessPointForObjectLambdaRequest& request) const; /** * A Callable wrapper for CreateAccessPointForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAccessPointForObjectLambdaOutcomeCallable CreateAccessPointForObjectLambdaCallable(const CreateAccessPointForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::CreateAccessPointForObjectLambda, request); } /** * An Async wrapper for CreateAccessPointForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAccessPointForObjectLambdaAsync(const CreateAccessPointForObjectLambdaRequestT& request, const CreateAccessPointForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::CreateAccessPointForObjectLambda, request, handler, context); } /** *

This action creates an Amazon S3 on Outposts bucket. To create an S3 * bucket, see Create * Bucket in the Amazon S3 API Reference.

Creates a new * Outposts bucket. By creating the bucket, you become the bucket owner. To create * an Outposts bucket, you must have S3 on Outposts. For more information, see Using * Amazon S3 on Outposts in Amazon S3 User Guide.

Not every * string is an acceptable bucket name. For information on bucket naming * restrictions, see Working * with Amazon S3 Buckets.

S3 on Outposts buckets support:

  • *

    Tags

  • LifecycleConfigurations for deleting expired * objects

For a complete list of restrictions and Amazon S3 * feature limitations on S3 on Outposts, see * Amazon S3 on Outposts Restrictions and Limitations.

For an example of * the request syntax for Amazon S3 on Outposts that uses the S3 on Outposts * endpoint hostname prefix and x-amz-outpost-id in your API request, * see the Examples * section.

The following actions are related to CreateBucket * for Amazon S3 on Outposts:

See Also:

AWS * API Reference

*/ virtual Model::CreateBucketOutcome CreateBucket(const Model::CreateBucketRequest& request) const; /** * A Callable wrapper for CreateBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBucketOutcomeCallable CreateBucketCallable(const CreateBucketRequestT& request) const { return SubmitCallable(&S3ControlClient::CreateBucket, request); } /** * An Async wrapper for CreateBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBucketAsync(const CreateBucketRequestT& request, const CreateBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::CreateBucket, request, handler, context); } /** *

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 S3 * Batch Operations in the Amazon S3 User Guide.

This action * creates a S3 Batch Operations job.

Related actions include:

See Also:

AWS * API Reference

*/ virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request) const; /** * A Callable wrapper for CreateJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request) const { return SubmitCallable(&S3ControlClient::CreateJob, request); } /** * An Async wrapper for CreateJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateJobAsync(const CreateJobRequestT& request, const CreateJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::CreateJob, request, handler, context); } /** *

Creates a Multi-Region Access Point and associates it with the specified * buckets. For more information about creating Multi-Region Access Points, see Creating * Multi-Region Access Points in the Amazon S3 User Guide.

This * action will always be routed to the US West (Oregon) Region. For more * information about the restrictions around managing Multi-Region Access Points, * see Managing * Multi-Region Access Points in the Amazon S3 User Guide.

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 * DescribeMultiRegionAccessPointOperation.

The following * actions are related to CreateMultiRegionAccessPoint:

See Also:

AWS * API Reference

*/ virtual Model::CreateMultiRegionAccessPointOutcome CreateMultiRegionAccessPoint(const Model::CreateMultiRegionAccessPointRequest& request) const; /** * A Callable wrapper for CreateMultiRegionAccessPoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMultiRegionAccessPointOutcomeCallable CreateMultiRegionAccessPointCallable(const CreateMultiRegionAccessPointRequestT& request) const { return SubmitCallable(&S3ControlClient::CreateMultiRegionAccessPoint, request); } /** * An Async wrapper for CreateMultiRegionAccessPoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMultiRegionAccessPointAsync(const CreateMultiRegionAccessPointRequestT& request, const CreateMultiRegionAccessPointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::CreateMultiRegionAccessPoint, request, handler, context); } /** *

Deletes the specified access point.

All Amazon S3 on Outposts REST API * requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following actions are related to * DeleteAccessPoint:

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccessPointOutcome DeleteAccessPoint(const Model::DeleteAccessPointRequest& request) const; /** * A Callable wrapper for DeleteAccessPoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccessPointOutcomeCallable DeleteAccessPointCallable(const DeleteAccessPointRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteAccessPoint, request); } /** * An Async wrapper for DeleteAccessPoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccessPointAsync(const DeleteAccessPointRequestT& request, const DeleteAccessPointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteAccessPoint, request, handler, context); } /** *

Deletes the specified Object Lambda Access Point.

The following * actions are related to DeleteAccessPointForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccessPointForObjectLambdaOutcome DeleteAccessPointForObjectLambda(const Model::DeleteAccessPointForObjectLambdaRequest& request) const; /** * A Callable wrapper for DeleteAccessPointForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccessPointForObjectLambdaOutcomeCallable DeleteAccessPointForObjectLambdaCallable(const DeleteAccessPointForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteAccessPointForObjectLambda, request); } /** * An Async wrapper for DeleteAccessPointForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccessPointForObjectLambdaAsync(const DeleteAccessPointForObjectLambdaRequestT& request, const DeleteAccessPointForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteAccessPointForObjectLambda, request, handler, context); } /** *

Deletes the access point policy for the specified access point.

*

All Amazon S3 on Outposts REST API requests for this action require an * additional parameter of x-amz-outpost-id to be passed with the * request. In addition, you must use an S3 on Outposts endpoint hostname prefix * instead of s3-control. For an example of the request syntax for * Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and * the x-amz-outpost-id derived by using the access point ARN, see the * Examples * section.

The following actions are related to * DeleteAccessPointPolicy:

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccessPointPolicyOutcome DeleteAccessPointPolicy(const Model::DeleteAccessPointPolicyRequest& request) const; /** * A Callable wrapper for DeleteAccessPointPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccessPointPolicyOutcomeCallable DeleteAccessPointPolicyCallable(const DeleteAccessPointPolicyRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteAccessPointPolicy, request); } /** * An Async wrapper for DeleteAccessPointPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccessPointPolicyAsync(const DeleteAccessPointPolicyRequestT& request, const DeleteAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteAccessPointPolicy, request, handler, context); } /** *

Removes the resource policy for an Object Lambda Access Point.

The * following actions are related to * DeleteAccessPointPolicyForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::DeleteAccessPointPolicyForObjectLambdaOutcome DeleteAccessPointPolicyForObjectLambda(const Model::DeleteAccessPointPolicyForObjectLambdaRequest& request) const; /** * A Callable wrapper for DeleteAccessPointPolicyForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAccessPointPolicyForObjectLambdaOutcomeCallable DeleteAccessPointPolicyForObjectLambdaCallable(const DeleteAccessPointPolicyForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteAccessPointPolicyForObjectLambda, request); } /** * An Async wrapper for DeleteAccessPointPolicyForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAccessPointPolicyForObjectLambdaAsync(const DeleteAccessPointPolicyForObjectLambdaRequestT& request, const DeleteAccessPointPolicyForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteAccessPointPolicyForObjectLambda, request, handler, context); } /** *

This action deletes an Amazon S3 on Outposts bucket. To delete an S3 * bucket, see DeleteBucket * in the Amazon S3 API Reference.

Deletes the Amazon S3 on * Outposts bucket. All objects (including all object versions and delete markers) * in the bucket must be deleted before the bucket itself can be deleted. For more * information, see Using * Amazon S3 on Outposts in Amazon S3 User Guide.

All Amazon S3 * on Outposts REST API requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

Related Resources

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketOutcome DeleteBucket(const Model::DeleteBucketRequest& request) const; /** * A Callable wrapper for DeleteBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketOutcomeCallable DeleteBucketCallable(const DeleteBucketRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteBucket, request); } /** * An Async wrapper for DeleteBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketAsync(const DeleteBucketRequestT& request, const DeleteBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteBucket, request, handler, context); } /** *

This action deletes an Amazon S3 on Outposts bucket's lifecycle * configuration. To delete an S3 bucket's lifecycle configuration, see DeleteBucketLifecycle * in the Amazon S3 API Reference.

Deletes the lifecycle * configuration from the specified Outposts bucket. Amazon S3 on Outposts removes * all the lifecycle configuration rules in the lifecycle subresource associated * with the bucket. Your objects never expire, and Amazon S3 on Outposts no longer * automatically deletes any objects on the basis of rules contained in the deleted * lifecycle configuration. For more information, see Using * Amazon S3 on Outposts in Amazon S3 User Guide.

To use this * action, you must have permission to perform the * s3-outposts:DeleteLifecycleConfiguration action. By default, the * bucket owner has this permission and the Outposts bucket owner can grant this * permission to others.

All Amazon S3 on Outposts REST API requests for * this action require an additional parameter of x-amz-outpost-id to * be passed with the request. In addition, you must use an S3 on Outposts endpoint * hostname prefix instead of s3-control. For an example of the * request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint * hostname prefix and the x-amz-outpost-id derived by using the * access point ARN, see the Examples * section.

For more information about object expiration, see Elements * to Describe Lifecycle Actions.

Related actions include:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketLifecycleConfigurationOutcome DeleteBucketLifecycleConfiguration(const Model::DeleteBucketLifecycleConfigurationRequest& request) const; /** * A Callable wrapper for DeleteBucketLifecycleConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketLifecycleConfigurationOutcomeCallable DeleteBucketLifecycleConfigurationCallable(const DeleteBucketLifecycleConfigurationRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteBucketLifecycleConfiguration, request); } /** * An Async wrapper for DeleteBucketLifecycleConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketLifecycleConfigurationAsync(const DeleteBucketLifecycleConfigurationRequestT& request, const DeleteBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteBucketLifecycleConfiguration, request, handler, context); } /** *

This action deletes an Amazon S3 on Outposts bucket policy. To delete * an S3 bucket policy, see DeleteBucketPolicy * in the Amazon S3 API Reference.

This implementation of * the DELETE action uses the policy subresource to delete the policy of a * specified Amazon S3 on Outposts bucket. If you are using an identity other than * the root user of the Amazon Web Services account that owns the bucket, the * calling identity must have the s3-outposts:DeleteBucketPolicy * permissions on the specified Outposts bucket and belong to the bucket owner's * account to use this action. For more information, see Using * Amazon S3 on Outposts in Amazon S3 User Guide.

If you don't * have DeleteBucketPolicy permissions, Amazon S3 returns a 403 * Access Denied error. If you have the correct permissions, but you're not * using an identity that belongs to the bucket owner's account, Amazon S3 returns * a 405 Method Not Allowed error.

As a security * precaution, the root user of the Amazon Web Services account that owns a bucket * can always use this action, even if the policy explicitly denies the root user * the ability to perform this action.

For more information * about bucket policies, see Using * Bucket Policies and User Policies.

All Amazon S3 on Outposts REST * API requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following actions are related to * DeleteBucketPolicy:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketPolicyOutcome DeleteBucketPolicy(const Model::DeleteBucketPolicyRequest& request) const; /** * A Callable wrapper for DeleteBucketPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketPolicyOutcomeCallable DeleteBucketPolicyCallable(const DeleteBucketPolicyRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteBucketPolicy, request); } /** * An Async wrapper for DeleteBucketPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketPolicyAsync(const DeleteBucketPolicyRequestT& request, const DeleteBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteBucketPolicy, request, handler, context); } /** *

This operation deletes an Amazon S3 on Outposts bucket's replication * configuration. To delete an S3 bucket's replication configuration, see DeleteBucketReplication * in the Amazon S3 API Reference.

Deletes the replication * configuration from the specified S3 on Outposts bucket.

To use this * operation, you must have permissions to perform the * s3-outposts:PutReplicationConfiguration action. The Outposts bucket * owner has this permission by default and can grant it to others. For more * information about permissions, see Setting * up IAM with S3 on Outposts and Managing * access to S3 on Outposts buckets in the Amazon S3 User Guide.

*

It can take a while to propagate PUT or * DELETE requests for a replication configuration to all S3 on * Outposts systems. Therefore, the replication configuration that's returned by a * GET request soon after a PUT or DELETE * request might return a more recent result than what's on the Outpost. If an * Outpost is offline, the delay in updating the replication configuration on that * Outpost can be significant.

All Amazon S3 on Outposts REST API * requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

For information about S3 replication on Outposts configuration, * see Replicating * objects for S3 on Outposts in the Amazon S3 User Guide.

The * following operations are related to DeleteBucketReplication:

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketReplicationOutcome DeleteBucketReplication(const Model::DeleteBucketReplicationRequest& request) const; /** * A Callable wrapper for DeleteBucketReplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketReplicationOutcomeCallable DeleteBucketReplicationCallable(const DeleteBucketReplicationRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteBucketReplication, request); } /** * An Async wrapper for DeleteBucketReplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketReplicationAsync(const DeleteBucketReplicationRequestT& request, const DeleteBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteBucketReplication, request, handler, context); } /** *

This action deletes an Amazon S3 on Outposts bucket's tags. To delete * an S3 bucket tags, see DeleteBucketTagging * in the Amazon S3 API Reference.

Deletes the tags from the * Outposts bucket. For more information, see Using * Amazon S3 on Outposts in Amazon S3 User Guide.

To use this * action, you must have permission to perform the PutBucketTagging * action. By default, the bucket owner has this permission and can grant this * permission to others.

All Amazon S3 on Outposts REST API requests for * this action require an additional parameter of x-amz-outpost-id to * be passed with the request. In addition, you must use an S3 on Outposts endpoint * hostname prefix instead of s3-control. For an example of the * request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint * hostname prefix and the x-amz-outpost-id derived by using the * access point ARN, see the Examples * section.

The following actions are related to * DeleteBucketTagging:

See Also:

AWS * API Reference

*/ virtual Model::DeleteBucketTaggingOutcome DeleteBucketTagging(const Model::DeleteBucketTaggingRequest& request) const; /** * A Callable wrapper for DeleteBucketTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBucketTaggingOutcomeCallable DeleteBucketTaggingCallable(const DeleteBucketTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteBucketTagging, request); } /** * An Async wrapper for DeleteBucketTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBucketTaggingAsync(const DeleteBucketTaggingRequestT& request, const DeleteBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteBucketTagging, request, handler, context); } /** *

Removes the entire tag set from the specified S3 Batch Operations job. To use * the DeleteJobTagging operation, you must have permission to perform * the s3:DeleteJobTagging action. For more information, see Controlling * access and labeling jobs using tags in the Amazon S3 User Guide.

*

Related actions include:

See Also:

AWS * API Reference

*/ virtual Model::DeleteJobTaggingOutcome DeleteJobTagging(const Model::DeleteJobTaggingRequest& request) const; /** * A Callable wrapper for DeleteJobTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteJobTaggingOutcomeCallable DeleteJobTaggingCallable(const DeleteJobTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteJobTagging, request); } /** * An Async wrapper for DeleteJobTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteJobTaggingAsync(const DeleteJobTaggingRequestT& request, const DeleteJobTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteJobTagging, request, handler, context); } /** *

Deletes a Multi-Region Access Point. This action does not delete the buckets * associated with the Multi-Region Access Point, only the Multi-Region Access * Point itself.

This action will always be routed to the US West (Oregon) * Region. For more information about the restrictions around managing Multi-Region * Access Points, see Managing * Multi-Region Access Points in the Amazon S3 User Guide.

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 * DescribeMultiRegionAccessPointOperation.

The following * actions are related to DeleteMultiRegionAccessPoint:

See Also:

AWS * API Reference

*/ virtual Model::DeleteMultiRegionAccessPointOutcome DeleteMultiRegionAccessPoint(const Model::DeleteMultiRegionAccessPointRequest& request) const; /** * A Callable wrapper for DeleteMultiRegionAccessPoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMultiRegionAccessPointOutcomeCallable DeleteMultiRegionAccessPointCallable(const DeleteMultiRegionAccessPointRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteMultiRegionAccessPoint, request); } /** * An Async wrapper for DeleteMultiRegionAccessPoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMultiRegionAccessPointAsync(const DeleteMultiRegionAccessPointRequestT& request, const DeleteMultiRegionAccessPointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteMultiRegionAccessPoint, request, handler, context); } /** *

Removes the PublicAccessBlock configuration for an Amazon Web * Services account. For more information, see * Using Amazon S3 block public access.

Related actions include:

*

See Also:

AWS * API Reference

*/ virtual Model::DeletePublicAccessBlockOutcome DeletePublicAccessBlock(const Model::DeletePublicAccessBlockRequest& request) const; /** * A Callable wrapper for DeletePublicAccessBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePublicAccessBlockOutcomeCallable DeletePublicAccessBlockCallable(const DeletePublicAccessBlockRequestT& request) const { return SubmitCallable(&S3ControlClient::DeletePublicAccessBlock, request); } /** * An Async wrapper for DeletePublicAccessBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePublicAccessBlockAsync(const DeletePublicAccessBlockRequestT& request, const DeletePublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeletePublicAccessBlock, request, handler, context); } /** *

Deletes the Amazon S3 Storage Lens configuration. For more information about * S3 Storage Lens, see Assessing * your storage activity and usage with Amazon S3 Storage Lens in the * Amazon S3 User Guide.

To use this action, you must have * permission to perform the s3:DeleteStorageLensConfiguration action. * For more information, see Setting * permissions to use Amazon S3 Storage Lens in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStorageLensConfigurationOutcome DeleteStorageLensConfiguration(const Model::DeleteStorageLensConfigurationRequest& request) const; /** * A Callable wrapper for DeleteStorageLensConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStorageLensConfigurationOutcomeCallable DeleteStorageLensConfigurationCallable(const DeleteStorageLensConfigurationRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteStorageLensConfiguration, request); } /** * An Async wrapper for DeleteStorageLensConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStorageLensConfigurationAsync(const DeleteStorageLensConfigurationRequestT& request, const DeleteStorageLensConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteStorageLensConfiguration, request, handler, context); } /** *

Deletes the Amazon S3 Storage Lens configuration tags. For more information * about S3 Storage Lens, see Assessing * your storage activity and usage with Amazon S3 Storage Lens in the * Amazon S3 User Guide.

To use this action, you must have * permission to perform the s3:DeleteStorageLensConfigurationTagging * action. For more information, see Setting * permissions to use Amazon S3 Storage Lens in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStorageLensConfigurationTaggingOutcome DeleteStorageLensConfigurationTagging(const Model::DeleteStorageLensConfigurationTaggingRequest& request) const; /** * A Callable wrapper for DeleteStorageLensConfigurationTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStorageLensConfigurationTaggingOutcomeCallable DeleteStorageLensConfigurationTaggingCallable(const DeleteStorageLensConfigurationTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::DeleteStorageLensConfigurationTagging, request); } /** * An Async wrapper for DeleteStorageLensConfigurationTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStorageLensConfigurationTaggingAsync(const DeleteStorageLensConfigurationTaggingRequestT& request, const DeleteStorageLensConfigurationTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DeleteStorageLensConfigurationTagging, request, handler, context); } /** *

Retrieves the configuration parameters and status for a Batch Operations job. * For more information, see S3 * Batch Operations in the Amazon S3 User Guide.

Related * actions include:

See Also:

AWS * API Reference

*/ virtual Model::DescribeJobOutcome DescribeJob(const Model::DescribeJobRequest& request) const; /** * A Callable wrapper for DescribeJob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeJobOutcomeCallable DescribeJobCallable(const DescribeJobRequestT& request) const { return SubmitCallable(&S3ControlClient::DescribeJob, request); } /** * An Async wrapper for DescribeJob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeJobAsync(const DescribeJobRequestT& request, const DescribeJobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DescribeJob, request, handler, context); } /** *

Retrieves the status of an asynchronous request to manage a Multi-Region * Access Point. For more information about managing Multi-Region Access Points and * how asynchronous requests work, see Managing * Multi-Region Access Points in the Amazon S3 User Guide.

The * following actions are related to GetMultiRegionAccessPoint:

*

See Also:

AWS * API Reference

*/ virtual Model::DescribeMultiRegionAccessPointOperationOutcome DescribeMultiRegionAccessPointOperation(const Model::DescribeMultiRegionAccessPointOperationRequest& request) const; /** * A Callable wrapper for DescribeMultiRegionAccessPointOperation that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMultiRegionAccessPointOperationOutcomeCallable DescribeMultiRegionAccessPointOperationCallable(const DescribeMultiRegionAccessPointOperationRequestT& request) const { return SubmitCallable(&S3ControlClient::DescribeMultiRegionAccessPointOperation, request); } /** * An Async wrapper for DescribeMultiRegionAccessPointOperation that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMultiRegionAccessPointOperationAsync(const DescribeMultiRegionAccessPointOperationRequestT& request, const DescribeMultiRegionAccessPointOperationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::DescribeMultiRegionAccessPointOperation, request, handler, context); } /** *

Returns configuration information about the specified access point.

*

All Amazon S3 on Outposts REST API requests for this action require an * additional parameter of x-amz-outpost-id to be passed with the * request. In addition, you must use an S3 on Outposts endpoint hostname prefix * instead of s3-control. For an example of the request syntax for * Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and * the x-amz-outpost-id derived by using the access point ARN, see the * Examples * section.

The following actions are related to * GetAccessPoint:

See Also:

AWS * API Reference

*/ virtual Model::GetAccessPointOutcome GetAccessPoint(const Model::GetAccessPointRequest& request) const; /** * A Callable wrapper for GetAccessPoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccessPointOutcomeCallable GetAccessPointCallable(const GetAccessPointRequestT& request) const { return SubmitCallable(&S3ControlClient::GetAccessPoint, request); } /** * An Async wrapper for GetAccessPoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccessPointAsync(const GetAccessPointRequestT& request, const GetAccessPointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetAccessPoint, request, handler, context); } /** *

Returns configuration for an Object Lambda Access Point.

The following * actions are related to * GetAccessPointConfigurationForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::GetAccessPointConfigurationForObjectLambdaOutcome GetAccessPointConfigurationForObjectLambda(const Model::GetAccessPointConfigurationForObjectLambdaRequest& request) const; /** * A Callable wrapper for GetAccessPointConfigurationForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccessPointConfigurationForObjectLambdaOutcomeCallable GetAccessPointConfigurationForObjectLambdaCallable(const GetAccessPointConfigurationForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::GetAccessPointConfigurationForObjectLambda, request); } /** * An Async wrapper for GetAccessPointConfigurationForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccessPointConfigurationForObjectLambdaAsync(const GetAccessPointConfigurationForObjectLambdaRequestT& request, const GetAccessPointConfigurationForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetAccessPointConfigurationForObjectLambda, request, handler, context); } /** *

Returns configuration information about the specified Object Lambda Access * Point

The following actions are related to * GetAccessPointForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::GetAccessPointForObjectLambdaOutcome GetAccessPointForObjectLambda(const Model::GetAccessPointForObjectLambdaRequest& request) const; /** * A Callable wrapper for GetAccessPointForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccessPointForObjectLambdaOutcomeCallable GetAccessPointForObjectLambdaCallable(const GetAccessPointForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::GetAccessPointForObjectLambda, request); } /** * An Async wrapper for GetAccessPointForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccessPointForObjectLambdaAsync(const GetAccessPointForObjectLambdaRequestT& request, const GetAccessPointForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetAccessPointForObjectLambda, request, handler, context); } /** *

Returns the access point policy associated with the specified access * point.

The following actions are related to * GetAccessPointPolicy:

See Also:

AWS * API Reference

*/ virtual Model::GetAccessPointPolicyOutcome GetAccessPointPolicy(const Model::GetAccessPointPolicyRequest& request) const; /** * A Callable wrapper for GetAccessPointPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccessPointPolicyOutcomeCallable GetAccessPointPolicyCallable(const GetAccessPointPolicyRequestT& request) const { return SubmitCallable(&S3ControlClient::GetAccessPointPolicy, request); } /** * An Async wrapper for GetAccessPointPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccessPointPolicyAsync(const GetAccessPointPolicyRequestT& request, const GetAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetAccessPointPolicy, request, handler, context); } /** *

Returns the resource policy for an Object Lambda Access Point.

The * following actions are related to * GetAccessPointPolicyForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::GetAccessPointPolicyForObjectLambdaOutcome GetAccessPointPolicyForObjectLambda(const Model::GetAccessPointPolicyForObjectLambdaRequest& request) const; /** * A Callable wrapper for GetAccessPointPolicyForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccessPointPolicyForObjectLambdaOutcomeCallable GetAccessPointPolicyForObjectLambdaCallable(const GetAccessPointPolicyForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::GetAccessPointPolicyForObjectLambda, request); } /** * An Async wrapper for GetAccessPointPolicyForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccessPointPolicyForObjectLambdaAsync(const GetAccessPointPolicyForObjectLambdaRequestT& request, const GetAccessPointPolicyForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetAccessPointPolicyForObjectLambda, request, handler, context); } /** *

Indicates whether the specified access point currently has a policy that * allows public access. For more information about public access through access * points, see Managing * Data Access with Amazon S3 access points in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetAccessPointPolicyStatusOutcome GetAccessPointPolicyStatus(const Model::GetAccessPointPolicyStatusRequest& request) const; /** * A Callable wrapper for GetAccessPointPolicyStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccessPointPolicyStatusOutcomeCallable GetAccessPointPolicyStatusCallable(const GetAccessPointPolicyStatusRequestT& request) const { return SubmitCallable(&S3ControlClient::GetAccessPointPolicyStatus, request); } /** * An Async wrapper for GetAccessPointPolicyStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccessPointPolicyStatusAsync(const GetAccessPointPolicyStatusRequestT& request, const GetAccessPointPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetAccessPointPolicyStatus, request, handler, context); } /** *

Returns the status of the resource policy associated with an Object Lambda * Access Point.

See Also:

AWS * API Reference

*/ virtual Model::GetAccessPointPolicyStatusForObjectLambdaOutcome GetAccessPointPolicyStatusForObjectLambda(const Model::GetAccessPointPolicyStatusForObjectLambdaRequest& request) const; /** * A Callable wrapper for GetAccessPointPolicyStatusForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccessPointPolicyStatusForObjectLambdaOutcomeCallable GetAccessPointPolicyStatusForObjectLambdaCallable(const GetAccessPointPolicyStatusForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::GetAccessPointPolicyStatusForObjectLambda, request); } /** * An Async wrapper for GetAccessPointPolicyStatusForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccessPointPolicyStatusForObjectLambdaAsync(const GetAccessPointPolicyStatusForObjectLambdaRequestT& request, const GetAccessPointPolicyStatusForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetAccessPointPolicyStatusForObjectLambda, request, handler, context); } /** *

Gets an Amazon S3 on Outposts bucket. For more information, see * Using Amazon S3 on Outposts in the Amazon S3 User Guide.

If * you are using an identity other than the root user of the Amazon Web Services * account that owns the Outposts bucket, the calling identity must have the * s3-outposts:GetBucket permissions on the specified Outposts bucket * and belong to the Outposts bucket owner's account in order to use this action. * Only users from Outposts bucket owner account with the right permissions can * perform actions on an Outposts bucket.

If you don't have * s3-outposts:GetBucket permissions or you're not using an identity * that belongs to the bucket owner's account, Amazon S3 returns a 403 Access * Denied error.

The following actions are related to * GetBucket for Amazon S3 on Outposts:

All Amazon S3 on * Outposts REST API requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

See Also:

AWS * API Reference

*/ virtual Model::GetBucketOutcome GetBucket(const Model::GetBucketRequest& request) const; /** * A Callable wrapper for GetBucket that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketOutcomeCallable GetBucketCallable(const GetBucketRequestT& request) const { return SubmitCallable(&S3ControlClient::GetBucket, request); } /** * An Async wrapper for GetBucket that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketAsync(const GetBucketRequestT& request, const GetBucketResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetBucket, request, handler, context); } /** *

This action gets an Amazon S3 on Outposts bucket's lifecycle * configuration. To get an S3 bucket's lifecycle configuration, see GetBucketLifecycleConfiguration * in the Amazon S3 API Reference.

Returns the lifecycle * configuration information set on the Outposts bucket. For more information, see * Using * Amazon S3 on Outposts and for information about lifecycle configuration, see * * Object Lifecycle Management in Amazon S3 User Guide.

To use * this action, you must have permission to perform the * s3-outposts:GetLifecycleConfiguration action. The Outposts bucket * owner has this permission, by default. The bucket owner can grant this * permission to others. For more information about permissions, see Permissions * Related to Bucket Subresource Operations and Managing * Access Permissions to Your Amazon S3 Resources.

All Amazon S3 on * Outposts REST API requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

GetBucketLifecycleConfiguration has the following * special error:

  • Error code: * NoSuchLifecycleConfiguration

    • Description: The * lifecycle configuration does not exist.

    • HTTP Status Code: 404 * Not Found

    • SOAP Fault Code Prefix: Client

    • *

The following actions are related to * GetBucketLifecycleConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketLifecycleConfigurationOutcome GetBucketLifecycleConfiguration(const Model::GetBucketLifecycleConfigurationRequest& request) const; /** * A Callable wrapper for GetBucketLifecycleConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketLifecycleConfigurationOutcomeCallable GetBucketLifecycleConfigurationCallable(const GetBucketLifecycleConfigurationRequestT& request) const { return SubmitCallable(&S3ControlClient::GetBucketLifecycleConfiguration, request); } /** * An Async wrapper for GetBucketLifecycleConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketLifecycleConfigurationAsync(const GetBucketLifecycleConfigurationRequestT& request, const GetBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetBucketLifecycleConfiguration, request, handler, context); } /** *

This action gets a bucket policy for an Amazon S3 on Outposts bucket. * To get a policy for an S3 bucket, see GetBucketPolicy * in the Amazon S3 API Reference.

Returns the policy of a * specified Outposts bucket. For more information, see Using * Amazon S3 on Outposts in the Amazon S3 User Guide.

If you are * using an identity other than the root user of the Amazon Web Services account * that owns the bucket, the calling identity must have the * GetBucketPolicy permissions on the specified bucket and belong to * the bucket owner's account in order to use this action.

Only users from * Outposts bucket owner account with the right permissions can perform actions on * an Outposts bucket. If you don't have s3-outposts:GetBucketPolicy * permissions or you're not using an identity that belongs to the bucket owner's * account, Amazon S3 returns a 403 Access Denied error.

*

As a security precaution, the root user of the Amazon Web * Services account that owns a bucket can always use this action, even if the * policy explicitly denies the root user the ability to perform this action.

*

For more information about bucket policies, see Using * Bucket Policies and User Policies.

All Amazon S3 on Outposts REST API * requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following actions are related to * GetBucketPolicy:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketPolicyOutcome GetBucketPolicy(const Model::GetBucketPolicyRequest& request) const; /** * A Callable wrapper for GetBucketPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketPolicyOutcomeCallable GetBucketPolicyCallable(const GetBucketPolicyRequestT& request) const { return SubmitCallable(&S3ControlClient::GetBucketPolicy, request); } /** * An Async wrapper for GetBucketPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketPolicyAsync(const GetBucketPolicyRequestT& request, const GetBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetBucketPolicy, request, handler, context); } /** *

This operation gets an Amazon S3 on Outposts bucket's replication * configuration. To get an S3 bucket's replication configuration, see GetBucketReplication * in the Amazon S3 API Reference.

Returns the replication * configuration of an S3 on Outposts bucket. For more information about S3 on * Outposts, see Using * Amazon S3 on Outposts in the Amazon S3 User Guide. For information * about S3 replication on Outposts configuration, see Replicating * objects for S3 on Outposts in the Amazon S3 User Guide.

*

It can take a while to propagate PUT or DELETE * requests for a replication configuration to all S3 on Outposts systems. * Therefore, the replication configuration that's returned by a GET * request soon after a PUT or DELETE request might * return a more recent result than what's on the Outpost. If an Outpost is * offline, the delay in updating the replication configuration on that Outpost can * be significant.

This action requires permissions for the * s3-outposts:GetReplicationConfiguration action. The Outposts bucket * owner has this permission by default and can grant it to others. For more * information about permissions, see Setting * up IAM with S3 on Outposts and Managing * access to S3 on Outposts bucket in the Amazon S3 User Guide.

*

All Amazon S3 on Outposts REST API requests for this action require an * additional parameter of x-amz-outpost-id to be passed with the * request. In addition, you must use an S3 on Outposts endpoint hostname prefix * instead of s3-control. For an example of the request syntax for * Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and * the x-amz-outpost-id derived by using the access point ARN, see the * Examples * section.

If you include the Filter element in a replication * configuration, you must also include the DeleteMarkerReplication, * Status, and Priority elements. The response also * returns those elements.

For information about S3 on Outposts replication * failure reasons, see Replication * failure reasons in the Amazon S3 User Guide.

The following * operations are related to GetBucketReplication:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketReplicationOutcome GetBucketReplication(const Model::GetBucketReplicationRequest& request) const; /** * A Callable wrapper for GetBucketReplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketReplicationOutcomeCallable GetBucketReplicationCallable(const GetBucketReplicationRequestT& request) const { return SubmitCallable(&S3ControlClient::GetBucketReplication, request); } /** * An Async wrapper for GetBucketReplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketReplicationAsync(const GetBucketReplicationRequestT& request, const GetBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetBucketReplication, request, handler, context); } /** *

This action gets an Amazon S3 on Outposts bucket's tags. To get an S3 * bucket tags, see GetBucketTagging * in the Amazon S3 API Reference.

Returns the tag set * associated with the Outposts bucket. For more information, see Using * Amazon S3 on Outposts in the Amazon S3 User Guide.

To use this * action, you must have permission to perform the GetBucketTagging * action. By default, the bucket owner has this permission and can grant this * permission to others.

GetBucketTagging has the following * special error:

  • Error code: NoSuchTagSetError

    *

    • Description: There is no tag set associated with the bucket.

      *

All Amazon S3 on Outposts REST API requests for this * action require an additional parameter of x-amz-outpost-id to be * passed with the request. In addition, you must use an S3 on Outposts endpoint * hostname prefix instead of s3-control. For an example of the * request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint * hostname prefix and the x-amz-outpost-id derived by using the * access point ARN, see the Examples * section.

The following actions are related to * GetBucketTagging:

See Also:

AWS * API Reference

*/ virtual Model::GetBucketTaggingOutcome GetBucketTagging(const Model::GetBucketTaggingRequest& request) const; /** * A Callable wrapper for GetBucketTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketTaggingOutcomeCallable GetBucketTaggingCallable(const GetBucketTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::GetBucketTagging, request); } /** * An Async wrapper for GetBucketTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketTaggingAsync(const GetBucketTaggingRequestT& request, const GetBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetBucketTagging, request, handler, context); } /** *

This operation returns the versioning state for S3 on Outposts buckets * only. To return the versioning state for an S3 bucket, see GetBucketVersioning * in the Amazon S3 API Reference.

Returns the versioning * state for an S3 on Outposts bucket. With S3 Versioning, you can save multiple * distinct copies of your objects and recover from unintended user actions and * application failures.

If you've never set versioning on your bucket, it * has no versioning state. In that case, the GetBucketVersioning * request does not return a versioning state value.

For more information * about versioning, see Versioning * in the Amazon S3 User Guide.

All Amazon S3 on Outposts REST API * requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following operations are related to * GetBucketVersioning for S3 on Outposts.

See Also:

AWS * API Reference

*/ virtual Model::GetBucketVersioningOutcome GetBucketVersioning(const Model::GetBucketVersioningRequest& request) const; /** * A Callable wrapper for GetBucketVersioning that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBucketVersioningOutcomeCallable GetBucketVersioningCallable(const GetBucketVersioningRequestT& request) const { return SubmitCallable(&S3ControlClient::GetBucketVersioning, request); } /** * An Async wrapper for GetBucketVersioning that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBucketVersioningAsync(const GetBucketVersioningRequestT& request, const GetBucketVersioningResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetBucketVersioning, request, handler, context); } /** *

Returns the tags on an S3 Batch Operations job. To use the * GetJobTagging operation, you must have permission to perform the * s3:GetJobTagging action. For more information, see Controlling * access and labeling jobs using tags in the Amazon S3 User Guide.

*

Related actions include:

See Also:

AWS * API Reference

*/ virtual Model::GetJobTaggingOutcome GetJobTagging(const Model::GetJobTaggingRequest& request) const; /** * A Callable wrapper for GetJobTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetJobTaggingOutcomeCallable GetJobTaggingCallable(const GetJobTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::GetJobTagging, request); } /** * An Async wrapper for GetJobTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetJobTaggingAsync(const GetJobTaggingRequestT& request, const GetJobTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetJobTagging, request, handler, context); } /** *

Returns configuration information about the specified Multi-Region Access * Point.

This action will always be routed to the US West (Oregon) Region. * For more information about the restrictions around managing Multi-Region Access * Points, see Managing * Multi-Region Access Points in the Amazon S3 User Guide.

The * following actions are related to GetMultiRegionAccessPoint:

*

See Also:

AWS * API Reference

*/ virtual Model::GetMultiRegionAccessPointOutcome GetMultiRegionAccessPoint(const Model::GetMultiRegionAccessPointRequest& request) const; /** * A Callable wrapper for GetMultiRegionAccessPoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMultiRegionAccessPointOutcomeCallable GetMultiRegionAccessPointCallable(const GetMultiRegionAccessPointRequestT& request) const { return SubmitCallable(&S3ControlClient::GetMultiRegionAccessPoint, request); } /** * An Async wrapper for GetMultiRegionAccessPoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMultiRegionAccessPointAsync(const GetMultiRegionAccessPointRequestT& request, const GetMultiRegionAccessPointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetMultiRegionAccessPoint, request, handler, context); } /** *

Returns the access control policy of the specified Multi-Region Access * Point.

This action will always be routed to the US West (Oregon) Region. * For more information about the restrictions around managing Multi-Region Access * Points, see Managing * Multi-Region Access Points in the Amazon S3 User Guide.

The * following actions are related to * GetMultiRegionAccessPointPolicy:

See Also:

AWS * API Reference

*/ virtual Model::GetMultiRegionAccessPointPolicyOutcome GetMultiRegionAccessPointPolicy(const Model::GetMultiRegionAccessPointPolicyRequest& request) const; /** * A Callable wrapper for GetMultiRegionAccessPointPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMultiRegionAccessPointPolicyOutcomeCallable GetMultiRegionAccessPointPolicyCallable(const GetMultiRegionAccessPointPolicyRequestT& request) const { return SubmitCallable(&S3ControlClient::GetMultiRegionAccessPointPolicy, request); } /** * An Async wrapper for GetMultiRegionAccessPointPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMultiRegionAccessPointPolicyAsync(const GetMultiRegionAccessPointPolicyRequestT& request, const GetMultiRegionAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetMultiRegionAccessPointPolicy, request, handler, context); } /** *

Indicates whether the specified Multi-Region Access Point has an access * control policy that allows public access.

This action will always be * routed to the US West (Oregon) Region. For more information about the * restrictions around managing Multi-Region Access Points, see Managing * Multi-Region Access Points in the Amazon S3 User Guide.

The * following actions are related to * GetMultiRegionAccessPointPolicyStatus:

See Also:

AWS * API Reference

*/ virtual Model::GetMultiRegionAccessPointPolicyStatusOutcome GetMultiRegionAccessPointPolicyStatus(const Model::GetMultiRegionAccessPointPolicyStatusRequest& request) const; /** * A Callable wrapper for GetMultiRegionAccessPointPolicyStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMultiRegionAccessPointPolicyStatusOutcomeCallable GetMultiRegionAccessPointPolicyStatusCallable(const GetMultiRegionAccessPointPolicyStatusRequestT& request) const { return SubmitCallable(&S3ControlClient::GetMultiRegionAccessPointPolicyStatus, request); } /** * An Async wrapper for GetMultiRegionAccessPointPolicyStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMultiRegionAccessPointPolicyStatusAsync(const GetMultiRegionAccessPointPolicyStatusRequestT& request, const GetMultiRegionAccessPointPolicyStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetMultiRegionAccessPointPolicyStatus, request, handler, context); } /** *

Returns the routing configuration for a Multi-Region Access Point, indicating * which Regions are active or passive.

To obtain routing control changes * and failover requests, use the Amazon S3 failover control infrastructure * endpoints in these five Amazon Web Services Regions:

  • * us-east-1

  • us-west-2

    • *

  • ap-southeast-2

  • * ap-northeast-1

  • eu-west-1

    *

Your Amazon S3 bucket does not need to be in these five * Regions.

See Also:

AWS * API Reference

*/ virtual Model::GetMultiRegionAccessPointRoutesOutcome GetMultiRegionAccessPointRoutes(const Model::GetMultiRegionAccessPointRoutesRequest& request) const; /** * A Callable wrapper for GetMultiRegionAccessPointRoutes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMultiRegionAccessPointRoutesOutcomeCallable GetMultiRegionAccessPointRoutesCallable(const GetMultiRegionAccessPointRoutesRequestT& request) const { return SubmitCallable(&S3ControlClient::GetMultiRegionAccessPointRoutes, request); } /** * An Async wrapper for GetMultiRegionAccessPointRoutes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMultiRegionAccessPointRoutesAsync(const GetMultiRegionAccessPointRoutesRequestT& request, const GetMultiRegionAccessPointRoutesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetMultiRegionAccessPointRoutes, request, handler, context); } /** *

Retrieves the PublicAccessBlock configuration for an Amazon Web * Services account. For more information, see * Using Amazon S3 block public access.

Related actions include:

*

See Also:

AWS * API Reference

*/ virtual Model::GetPublicAccessBlockOutcome GetPublicAccessBlock(const Model::GetPublicAccessBlockRequest& request) const; /** * A Callable wrapper for GetPublicAccessBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPublicAccessBlockOutcomeCallable GetPublicAccessBlockCallable(const GetPublicAccessBlockRequestT& request) const { return SubmitCallable(&S3ControlClient::GetPublicAccessBlock, request); } /** * An Async wrapper for GetPublicAccessBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPublicAccessBlockAsync(const GetPublicAccessBlockRequestT& request, const GetPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetPublicAccessBlock, request, handler, context); } /** *

Gets the Amazon S3 Storage Lens configuration. For more information, see Assessing * your storage activity and usage with Amazon S3 Storage Lens in the * Amazon S3 User Guide. For a complete list of S3 Storage Lens metrics, see * S3 * Storage Lens metrics glossary in the Amazon S3 User Guide.

*

To use this action, you must have permission to perform the * s3:GetStorageLensConfiguration action. For more information, see Setting * permissions to use Amazon S3 Storage Lens in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetStorageLensConfigurationOutcome GetStorageLensConfiguration(const Model::GetStorageLensConfigurationRequest& request) const; /** * A Callable wrapper for GetStorageLensConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStorageLensConfigurationOutcomeCallable GetStorageLensConfigurationCallable(const GetStorageLensConfigurationRequestT& request) const { return SubmitCallable(&S3ControlClient::GetStorageLensConfiguration, request); } /** * An Async wrapper for GetStorageLensConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStorageLensConfigurationAsync(const GetStorageLensConfigurationRequestT& request, const GetStorageLensConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetStorageLensConfiguration, request, handler, context); } /** *

Gets the tags of Amazon S3 Storage Lens configuration. For more information * about S3 Storage Lens, see Assessing * your storage activity and usage with Amazon S3 Storage Lens in the * Amazon S3 User Guide.

To use this action, you must have * permission to perform the s3:GetStorageLensConfigurationTagging * action. For more information, see Setting * permissions to use Amazon S3 Storage Lens in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::GetStorageLensConfigurationTaggingOutcome GetStorageLensConfigurationTagging(const Model::GetStorageLensConfigurationTaggingRequest& request) const; /** * A Callable wrapper for GetStorageLensConfigurationTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStorageLensConfigurationTaggingOutcomeCallable GetStorageLensConfigurationTaggingCallable(const GetStorageLensConfigurationTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::GetStorageLensConfigurationTagging, request); } /** * An Async wrapper for GetStorageLensConfigurationTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStorageLensConfigurationTaggingAsync(const GetStorageLensConfigurationTaggingRequestT& request, const GetStorageLensConfigurationTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::GetStorageLensConfigurationTagging, request, handler, context); } /** *

Returns a list of the access points that are owned by the current account * that's associated with the specified bucket. You can retrieve up to 1000 access * points per call. If the specified bucket has more than 1,000 access points (or * the number specified in maxResults, whichever is less), the * response will include a continuation token that you can use to list the * additional access points.

All Amazon S3 on Outposts REST API * requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following actions are related to * ListAccessPoints:

See Also:

AWS * API Reference

*/ virtual Model::ListAccessPointsOutcome ListAccessPoints(const Model::ListAccessPointsRequest& request) const; /** * A Callable wrapper for ListAccessPoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAccessPointsOutcomeCallable ListAccessPointsCallable(const ListAccessPointsRequestT& request) const { return SubmitCallable(&S3ControlClient::ListAccessPoints, request); } /** * An Async wrapper for ListAccessPoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAccessPointsAsync(const ListAccessPointsRequestT& request, const ListAccessPointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::ListAccessPoints, request, handler, context); } /** *

Returns some or all (up to 1,000) access points associated with the Object * Lambda Access Point per call. If there are more access points than what can be * returned in one call, the response will include a continuation token that you * can use to list the additional access points.

The following actions are * related to ListAccessPointsForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::ListAccessPointsForObjectLambdaOutcome ListAccessPointsForObjectLambda(const Model::ListAccessPointsForObjectLambdaRequest& request) const; /** * A Callable wrapper for ListAccessPointsForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAccessPointsForObjectLambdaOutcomeCallable ListAccessPointsForObjectLambdaCallable(const ListAccessPointsForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::ListAccessPointsForObjectLambda, request); } /** * An Async wrapper for ListAccessPointsForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAccessPointsForObjectLambdaAsync(const ListAccessPointsForObjectLambdaRequestT& request, const ListAccessPointsForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::ListAccessPointsForObjectLambda, request, handler, context); } /** *

Lists current S3 Batch Operations jobs and jobs that have ended within the * last 30 days for the Amazon Web Services account making the request. For more * information, see S3 * Batch Operations in the Amazon S3 User Guide.

Related actions * include:

See Also:

AWS * API Reference

*/ virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request) const; /** * A Callable wrapper for ListJobs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request) const { return SubmitCallable(&S3ControlClient::ListJobs, request); } /** * An Async wrapper for ListJobs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListJobsAsync(const ListJobsRequestT& request, const ListJobsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::ListJobs, request, handler, context); } /** *

Returns a list of the Multi-Region Access Points currently associated with * the specified Amazon Web Services account. Each call can return up to 100 * Multi-Region Access Points, the maximum number of Multi-Region Access Points * that can be associated with a single account.

This action will always be * routed to the US West (Oregon) Region. For more information about the * restrictions around managing Multi-Region Access Points, see Managing * Multi-Region Access Points in the Amazon S3 User Guide.

The * following actions are related to ListMultiRegionAccessPoint:

*

See Also:

AWS * API Reference

*/ virtual Model::ListMultiRegionAccessPointsOutcome ListMultiRegionAccessPoints(const Model::ListMultiRegionAccessPointsRequest& request) const; /** * A Callable wrapper for ListMultiRegionAccessPoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListMultiRegionAccessPointsOutcomeCallable ListMultiRegionAccessPointsCallable(const ListMultiRegionAccessPointsRequestT& request) const { return SubmitCallable(&S3ControlClient::ListMultiRegionAccessPoints, request); } /** * An Async wrapper for ListMultiRegionAccessPoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListMultiRegionAccessPointsAsync(const ListMultiRegionAccessPointsRequestT& request, const ListMultiRegionAccessPointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::ListMultiRegionAccessPoints, request, handler, context); } /** *

Returns a list of all Outposts buckets in an Outpost that are owned by the * authenticated sender of the request. For more information, see Using * Amazon S3 on Outposts in the Amazon S3 User Guide.

For an * example of the request syntax for Amazon S3 on Outposts that uses the S3 on * Outposts endpoint hostname prefix and x-amz-outpost-id in your * request, see the Examples * section.

See Also:

AWS * API Reference

*/ virtual Model::ListRegionalBucketsOutcome ListRegionalBuckets(const Model::ListRegionalBucketsRequest& request) const; /** * A Callable wrapper for ListRegionalBuckets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRegionalBucketsOutcomeCallable ListRegionalBucketsCallable(const ListRegionalBucketsRequestT& request) const { return SubmitCallable(&S3ControlClient::ListRegionalBuckets, request); } /** * An Async wrapper for ListRegionalBuckets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRegionalBucketsAsync(const ListRegionalBucketsRequestT& request, const ListRegionalBucketsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::ListRegionalBuckets, request, handler, context); } /** *

Gets a list of Amazon S3 Storage Lens configurations. For more information * about S3 Storage Lens, see Assessing * your storage activity and usage with Amazon S3 Storage Lens in the * Amazon S3 User Guide.

To use this action, you must have * permission to perform the s3:ListStorageLensConfigurations action. * For more information, see Setting * permissions to use Amazon S3 Storage Lens in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListStorageLensConfigurationsOutcome ListStorageLensConfigurations(const Model::ListStorageLensConfigurationsRequest& request) const; /** * A Callable wrapper for ListStorageLensConfigurations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStorageLensConfigurationsOutcomeCallable ListStorageLensConfigurationsCallable(const ListStorageLensConfigurationsRequestT& request) const { return SubmitCallable(&S3ControlClient::ListStorageLensConfigurations, request); } /** * An Async wrapper for ListStorageLensConfigurations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStorageLensConfigurationsAsync(const ListStorageLensConfigurationsRequestT& request, const ListStorageLensConfigurationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::ListStorageLensConfigurations, request, handler, context); } /** *

Replaces configuration for an Object Lambda Access Point.

The * following actions are related to * PutAccessPointConfigurationForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::PutAccessPointConfigurationForObjectLambdaOutcome PutAccessPointConfigurationForObjectLambda(const Model::PutAccessPointConfigurationForObjectLambdaRequest& request) const; /** * A Callable wrapper for PutAccessPointConfigurationForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAccessPointConfigurationForObjectLambdaOutcomeCallable PutAccessPointConfigurationForObjectLambdaCallable(const PutAccessPointConfigurationForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::PutAccessPointConfigurationForObjectLambda, request); } /** * An Async wrapper for PutAccessPointConfigurationForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAccessPointConfigurationForObjectLambdaAsync(const PutAccessPointConfigurationForObjectLambdaRequestT& request, const PutAccessPointConfigurationForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutAccessPointConfigurationForObjectLambda, request, handler, context); } /** *

Associates an access policy with the specified access point. Each access * point can have only one policy, so a request made to this API replaces any * existing policy associated with the specified access point.

All * Amazon S3 on Outposts REST API requests for this action require an additional * parameter of x-amz-outpost-id to be passed with the request. In * addition, you must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following actions are related to * PutAccessPointPolicy:

See Also:

AWS * API Reference

*/ virtual Model::PutAccessPointPolicyOutcome PutAccessPointPolicy(const Model::PutAccessPointPolicyRequest& request) const; /** * A Callable wrapper for PutAccessPointPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAccessPointPolicyOutcomeCallable PutAccessPointPolicyCallable(const PutAccessPointPolicyRequestT& request) const { return SubmitCallable(&S3ControlClient::PutAccessPointPolicy, request); } /** * An Async wrapper for PutAccessPointPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAccessPointPolicyAsync(const PutAccessPointPolicyRequestT& request, const PutAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutAccessPointPolicy, request, handler, context); } /** *

Creates or replaces resource policy for an Object Lambda Access Point. For an * example policy, see Creating * Object Lambda Access Points in the Amazon S3 User Guide.

The * following actions are related to * PutAccessPointPolicyForObjectLambda:

See Also:

AWS * API Reference

*/ virtual Model::PutAccessPointPolicyForObjectLambdaOutcome PutAccessPointPolicyForObjectLambda(const Model::PutAccessPointPolicyForObjectLambdaRequest& request) const; /** * A Callable wrapper for PutAccessPointPolicyForObjectLambda that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutAccessPointPolicyForObjectLambdaOutcomeCallable PutAccessPointPolicyForObjectLambdaCallable(const PutAccessPointPolicyForObjectLambdaRequestT& request) const { return SubmitCallable(&S3ControlClient::PutAccessPointPolicyForObjectLambda, request); } /** * An Async wrapper for PutAccessPointPolicyForObjectLambda that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutAccessPointPolicyForObjectLambdaAsync(const PutAccessPointPolicyForObjectLambdaRequestT& request, const PutAccessPointPolicyForObjectLambdaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutAccessPointPolicyForObjectLambda, request, handler, context); } /** *

This action puts a lifecycle configuration to an Amazon S3 on Outposts * bucket. To put a lifecycle configuration to an S3 bucket, see PutBucketLifecycleConfiguration * in the Amazon S3 API Reference.

Creates a new lifecycle * configuration for the S3 on Outposts bucket or replaces an existing lifecycle * configuration. Outposts buckets only support lifecycle configurations that * delete/expire objects after a certain period of time and abort incomplete * multipart uploads.

All Amazon S3 on Outposts REST API requests for * this action require an additional parameter of x-amz-outpost-id to * be passed with the request. In addition, you must use an S3 on Outposts endpoint * hostname prefix instead of s3-control. For an example of the * request syntax for Amazon S3 on Outposts that uses the S3 on Outposts endpoint * hostname prefix and the x-amz-outpost-id derived by using the * access point ARN, see the Examples * section.

The following actions are related to * PutBucketLifecycleConfiguration:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketLifecycleConfigurationOutcome PutBucketLifecycleConfiguration(const Model::PutBucketLifecycleConfigurationRequest& request) const; /** * A Callable wrapper for PutBucketLifecycleConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketLifecycleConfigurationOutcomeCallable PutBucketLifecycleConfigurationCallable(const PutBucketLifecycleConfigurationRequestT& request) const { return SubmitCallable(&S3ControlClient::PutBucketLifecycleConfiguration, request); } /** * An Async wrapper for PutBucketLifecycleConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketLifecycleConfigurationAsync(const PutBucketLifecycleConfigurationRequestT& request, const PutBucketLifecycleConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutBucketLifecycleConfiguration, request, handler, context); } /** *

This action puts a bucket policy to an Amazon S3 on Outposts bucket. * To put a policy on an S3 bucket, see PutBucketPolicy * in the Amazon S3 API Reference.

Applies an Amazon S3 * bucket policy to an Outposts bucket. For more information, see Using * Amazon S3 on Outposts in the Amazon S3 User Guide.

If you are * using an identity other than the root user of the Amazon Web Services account * that owns the Outposts bucket, the calling identity must have the * PutBucketPolicy permissions on the specified Outposts bucket and * belong to the bucket owner's account in order to use this action.

If you * don't have PutBucketPolicy permissions, Amazon S3 returns a * 403 Access Denied error. If you have the correct permissions, but * you're not using an identity that belongs to the bucket owner's account, Amazon * S3 returns a 405 Method Not Allowed error.

As a * security precaution, the root user of the Amazon Web Services account that owns * a bucket can always use this action, even if the policy explicitly denies the * root user the ability to perform this action.

For more * information about bucket policies, see Using * Bucket Policies and User Policies.

All Amazon S3 on Outposts REST API * requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following actions are related to * PutBucketPolicy:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketPolicyOutcome PutBucketPolicy(const Model::PutBucketPolicyRequest& request) const; /** * A Callable wrapper for PutBucketPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketPolicyOutcomeCallable PutBucketPolicyCallable(const PutBucketPolicyRequestT& request) const { return SubmitCallable(&S3ControlClient::PutBucketPolicy, request); } /** * An Async wrapper for PutBucketPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketPolicyAsync(const PutBucketPolicyRequestT& request, const PutBucketPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutBucketPolicy, request, handler, context); } /** *

This action creates an Amazon S3 on Outposts bucket's replication * configuration. To create an S3 bucket's replication configuration, see PutBucketReplication * in the Amazon S3 API Reference.

Creates a replication * configuration or replaces an existing one. For information about S3 replication * on Outposts configuration, see Replicating * objects for S3 on Outposts in the Amazon S3 User Guide.

*

It can take a while to propagate PUT or DELETE * requests for a replication configuration to all S3 on Outposts systems. * Therefore, the replication configuration that's returned by a GET * request soon after a PUT or DELETE request might * return a more recent result than what's on the Outpost. If an Outpost is * offline, the delay in updating the replication configuration on that Outpost can * be significant.

Specify the replication configuration in the * request body. In the replication configuration, you provide the following * information:

  • The name of the destination bucket or buckets * where you want S3 on Outposts to replicate objects

  • The * Identity and Access Management (IAM) role that S3 on Outposts can assume to * replicate objects on your behalf

  • Other relevant information, * such as replication rules

A replication configuration must * include at least one rule and can contain a maximum of 100. Each rule identifies * a subset of objects to replicate by filtering the objects in the source Outposts * bucket. To choose additional subsets of objects to replicate, add a rule for * each subset.

To specify a subset of the objects in the source Outposts * bucket to apply a replication rule to, add the Filter element as a * child of the Rule element. You can filter objects based on an * object key prefix, one or more object tags, or both. When you add the * Filter element in the configuration, you must also add the * following elements: DeleteMarkerReplication, Status, * and Priority.

Using PutBucketReplication on * Outposts requires that both the source and destination buckets must have * versioning enabled. For information about enabling versioning on a bucket, see * Managing * S3 Versioning for your S3 on Outposts bucket.

For information about * S3 on Outposts replication failure reasons, see Replication * failure reasons in the Amazon S3 User Guide.

Handling * Replication of Encrypted Objects

Outposts buckets are encrypted at * all times. All the objects in the source Outposts bucket are encrypted and can * be replicated. Also, all the replicas in the destination Outposts bucket are * encrypted with the same encryption key as the objects in the source Outposts * bucket.

Permissions

To create a * PutBucketReplication request, you must have * s3-outposts:PutReplicationConfiguration permissions for the bucket. * The Outposts bucket owner has this permission by default and can grant it to * others. For more information about permissions, see Setting * up IAM with S3 on Outposts and Managing * access to S3 on Outposts buckets.

To perform this operation, * the user or role must also have the iam:CreateRole and * iam:PassRole permissions. For more information, see Granting * a user permissions to pass a role to an Amazon Web Services service.

*

All Amazon S3 on Outposts REST API requests for this action require * an additional parameter of x-amz-outpost-id to be passed with the * request. In addition, you must use an S3 on Outposts endpoint hostname prefix * instead of s3-control. For an example of the request syntax for * Amazon S3 on Outposts that uses the S3 on Outposts endpoint hostname prefix and * the x-amz-outpost-id derived by using the access point ARN, see the * Examples * section.

The following operations are related to * PutBucketReplication:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketReplicationOutcome PutBucketReplication(const Model::PutBucketReplicationRequest& request) const; /** * A Callable wrapper for PutBucketReplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketReplicationOutcomeCallable PutBucketReplicationCallable(const PutBucketReplicationRequestT& request) const { return SubmitCallable(&S3ControlClient::PutBucketReplication, request); } /** * An Async wrapper for PutBucketReplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketReplicationAsync(const PutBucketReplicationRequestT& request, const PutBucketReplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutBucketReplication, request, handler, context); } /** *

This action puts tags on an Amazon S3 on Outposts bucket. To put tags * on an S3 bucket, see PutBucketTagging * in the Amazon S3 API Reference.

Sets the tags for an S3 * on Outposts bucket. For more information, see Using * Amazon S3 on Outposts in the Amazon S3 User Guide.

Use tags to * organize your Amazon Web Services bill to reflect your own cost structure. To do * this, sign up to get your Amazon Web Services account bill with tag key values * included. Then, to see the cost of combined resources, organize your billing * information according to resources with the same tag key values. For example, * you can tag several resources with a specific application name, and then * organize your billing information to see the total cost of that application * across several services. For more information, see Cost * allocation and tagging.

Within a bucket, if you add a tag that * has the same key as an existing tag, the new value overwrites the old value. For * more information, see * Using cost allocation in Amazon S3 bucket tags.

To use this * action, you must have permissions to perform the * s3-outposts:PutBucketTagging action. The Outposts bucket owner has * this permission by default and can grant this permission to others. For more * information about permissions, see * Permissions Related to Bucket Subresource Operations and Managing * access permissions to your Amazon S3 resources.

* PutBucketTagging has the following special errors:

  • *

    Error code: InvalidTagError

  • Error code: MalformedXMLError

    • *

      Description: The XML provided does not match the schema.

    *

  • Error code: OperationAbortedError

    • *

      Description: A conflicting conditional action is currently in progress * against this resource. Try again.

  • Error code: * InternalError

    • Description: The service was unable * to apply the provided tag to the bucket.

All * Amazon S3 on Outposts REST API requests for this action require an additional * parameter of x-amz-outpost-id to be passed with the request. In * addition, you must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following actions are related to * PutBucketTagging:

See Also:

AWS * API Reference

*/ virtual Model::PutBucketTaggingOutcome PutBucketTagging(const Model::PutBucketTaggingRequest& request) const; /** * A Callable wrapper for PutBucketTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketTaggingOutcomeCallable PutBucketTaggingCallable(const PutBucketTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::PutBucketTagging, request); } /** * An Async wrapper for PutBucketTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketTaggingAsync(const PutBucketTaggingRequestT& request, const PutBucketTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutBucketTagging, request, handler, context); } /** *

This operation sets the versioning state for S3 on Outposts buckets * only. To set the versioning state for an S3 bucket, see PutBucketVersioning * in the Amazon S3 API Reference.

Sets the versioning state * for an S3 on Outposts bucket. With S3 Versioning, you can save multiple distinct * copies of your objects and recover from unintended user actions and application * failures.

You can set the versioning state to one of the following:

*

  • Enabled - Enables versioning for the objects in the bucket. * All objects added to the bucket receive a unique version ID.

  • * Suspended - Suspends versioning for the objects in the bucket. All * objects added to the bucket receive the version ID null.

    • *

If you've never set versioning on your bucket, it has no versioning * state. In that case, a * GetBucketVersioning request does not return a versioning state value.

*

When you enable S3 Versioning, for each object in your bucket, you have a * current version and zero or more noncurrent versions. You can configure your * bucket S3 Lifecycle rules to expire noncurrent versions after a specified time * period. For more information, see * Creating and managing a lifecycle configuration for your S3 on Outposts * bucket in the Amazon S3 User Guide.

If you have an object * expiration lifecycle configuration in your non-versioned bucket and you want to * maintain the same permanent delete behavior when you enable versioning, you must * add a noncurrent expiration policy. The noncurrent expiration lifecycle * configuration will manage the deletes of the noncurrent object versions in the * version-enabled bucket. For more information, see Versioning * in the Amazon S3 User Guide.

All Amazon S3 on Outposts REST API * requests for this action require an additional parameter of * x-amz-outpost-id to be passed with the request. In addition, you * must use an S3 on Outposts endpoint hostname prefix instead of * s3-control. For an example of the request syntax for Amazon S3 on * Outposts that uses the S3 on Outposts endpoint hostname prefix and the * x-amz-outpost-id derived by using the access point ARN, see the Examples * section.

The following operations are related to * PutBucketVersioning for S3 on Outposts.

See Also:

AWS * API Reference

*/ virtual Model::PutBucketVersioningOutcome PutBucketVersioning(const Model::PutBucketVersioningRequest& request) const; /** * A Callable wrapper for PutBucketVersioning that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutBucketVersioningOutcomeCallable PutBucketVersioningCallable(const PutBucketVersioningRequestT& request) const { return SubmitCallable(&S3ControlClient::PutBucketVersioning, request); } /** * An Async wrapper for PutBucketVersioning that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutBucketVersioningAsync(const PutBucketVersioningRequestT& request, const PutBucketVersioningResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutBucketVersioning, request, handler, context); } /** *

Sets the supplied tag-set on an S3 Batch Operations job.

A tag is a * key-value pair. You can associate S3 Batch Operations tags with any job by * sending a PUT request against the tagging subresource that is associated with * the job. To modify the existing tag set, you can either replace the existing tag * set entirely, or make changes within the existing tag set by retrieving the * existing tag set using GetJobTagging, * modify that tag set, and use this action to replace the tag set with the one you * modified. For more information, see Controlling * access and labeling jobs using tags in the Amazon S3 User Guide.

*

  • If you send this request with an empty tag set, Amazon * S3 deletes the existing tag set on the Batch Operations job. If you use this * method, you are charged for a Tier 1 Request (PUT). For more information, see Amazon S3 pricing.

  • *

    For deleting existing tags for your Batch Operations job, a DeleteJobTagging * request is preferred because it achieves the same result without incurring * charges.

  • A few things to consider about using tags:

      *

    • Amazon S3 limits the maximum number of tags to 50 tags per job.

      *

    • You can associate up to 50 tags with a job as long as they have * unique tag keys.

    • A tag key can be up to 128 Unicode characters * in length, and tag values can be up to 256 Unicode characters in length.

      *

    • The key and values are case sensitive.

    • For * tagging-related restrictions related to characters and encodings, see User-Defined * Tag Restrictions in the Billing and Cost Management User Guide.

      *

To use the PutJobTagging * operation, you must have permission to perform the s3:PutJobTagging * action.

Related actions include:

See Also:

AWS * API Reference

*/ virtual Model::PutJobTaggingOutcome PutJobTagging(const Model::PutJobTaggingRequest& request) const; /** * A Callable wrapper for PutJobTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutJobTaggingOutcomeCallable PutJobTaggingCallable(const PutJobTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::PutJobTagging, request); } /** * An Async wrapper for PutJobTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutJobTaggingAsync(const PutJobTaggingRequestT& request, const PutJobTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutJobTagging, request, handler, context); } /** *

Associates an access control policy with the specified Multi-Region Access * Point. Each Multi-Region Access Point can have only one policy, so a request * made to this action replaces any existing policy that is associated with the * specified Multi-Region Access Point.

This action will always be routed to * the US West (Oregon) Region. For more information about the restrictions around * managing Multi-Region Access Points, see Managing * Multi-Region Access Points in the Amazon S3 User Guide.

The * following actions are related to * PutMultiRegionAccessPointPolicy:

See Also:

AWS * API Reference

*/ virtual Model::PutMultiRegionAccessPointPolicyOutcome PutMultiRegionAccessPointPolicy(const Model::PutMultiRegionAccessPointPolicyRequest& request) const; /** * A Callable wrapper for PutMultiRegionAccessPointPolicy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutMultiRegionAccessPointPolicyOutcomeCallable PutMultiRegionAccessPointPolicyCallable(const PutMultiRegionAccessPointPolicyRequestT& request) const { return SubmitCallable(&S3ControlClient::PutMultiRegionAccessPointPolicy, request); } /** * An Async wrapper for PutMultiRegionAccessPointPolicy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutMultiRegionAccessPointPolicyAsync(const PutMultiRegionAccessPointPolicyRequestT& request, const PutMultiRegionAccessPointPolicyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutMultiRegionAccessPointPolicy, request, handler, context); } /** *

Creates or modifies the PublicAccessBlock configuration for an * Amazon Web Services account. For this operation, users must have the * s3:PutAccountPublicAccessBlock permission. For more information, * see * Using Amazon S3 block public access.

Related actions include:

*

See Also:

AWS * API Reference

*/ virtual Model::PutPublicAccessBlockOutcome PutPublicAccessBlock(const Model::PutPublicAccessBlockRequest& request) const; /** * A Callable wrapper for PutPublicAccessBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutPublicAccessBlockOutcomeCallable PutPublicAccessBlockCallable(const PutPublicAccessBlockRequestT& request) const { return SubmitCallable(&S3ControlClient::PutPublicAccessBlock, request); } /** * An Async wrapper for PutPublicAccessBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutPublicAccessBlockAsync(const PutPublicAccessBlockRequestT& request, const PutPublicAccessBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutPublicAccessBlock, request, handler, context); } /** *

Puts an Amazon S3 Storage Lens configuration. For more information about S3 * Storage Lens, see Working * with Amazon S3 Storage Lens in the Amazon S3 User Guide. For a * complete list of S3 Storage Lens metrics, see S3 * Storage Lens metrics glossary in the Amazon S3 User Guide.

*

To use this action, you must have permission to perform the * s3:PutStorageLensConfiguration action. For more information, see Setting * permissions to use Amazon S3 Storage Lens in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::PutStorageLensConfigurationOutcome PutStorageLensConfiguration(const Model::PutStorageLensConfigurationRequest& request) const; /** * A Callable wrapper for PutStorageLensConfiguration that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutStorageLensConfigurationOutcomeCallable PutStorageLensConfigurationCallable(const PutStorageLensConfigurationRequestT& request) const { return SubmitCallable(&S3ControlClient::PutStorageLensConfiguration, request); } /** * An Async wrapper for PutStorageLensConfiguration that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutStorageLensConfigurationAsync(const PutStorageLensConfigurationRequestT& request, const PutStorageLensConfigurationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutStorageLensConfiguration, request, handler, context); } /** *

Put or replace tags on an existing Amazon S3 Storage Lens configuration. For * more information about S3 Storage Lens, see Assessing * your storage activity and usage with Amazon S3 Storage Lens in the * Amazon S3 User Guide.

To use this action, you must have * permission to perform the s3:PutStorageLensConfigurationTagging * action. For more information, see Setting * permissions to use Amazon S3 Storage Lens in the Amazon S3 User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::PutStorageLensConfigurationTaggingOutcome PutStorageLensConfigurationTagging(const Model::PutStorageLensConfigurationTaggingRequest& request) const; /** * A Callable wrapper for PutStorageLensConfigurationTagging that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutStorageLensConfigurationTaggingOutcomeCallable PutStorageLensConfigurationTaggingCallable(const PutStorageLensConfigurationTaggingRequestT& request) const { return SubmitCallable(&S3ControlClient::PutStorageLensConfigurationTagging, request); } /** * An Async wrapper for PutStorageLensConfigurationTagging that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutStorageLensConfigurationTaggingAsync(const PutStorageLensConfigurationTaggingRequestT& request, const PutStorageLensConfigurationTaggingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::PutStorageLensConfigurationTagging, request, handler, context); } /** *

Submits an updated route configuration for a Multi-Region Access Point. This * API operation updates the routing status for the specified Regions from active * to passive, or from passive to active. A value of 0 indicates a * passive status, which means that traffic won't be routed to the specified * Region. A value of 100 indicates an active status, which means that * traffic will be routed to the specified Region. At least one Region must be * active at all times.

When the routing configuration is changed, any * in-progress operations (uploads, copies, deletes, and so on) to formerly active * Regions will continue to run to their final completion state (success or * failure). The routing configurations of any Regions that aren’t specified remain * unchanged.

Updated routing configurations might not be immediately * applied. It can take up to 2 minutes for your changes to take effect.

*

To submit routing control changes and failover requests, use the * Amazon S3 failover control infrastructure endpoints in these five Amazon Web * Services Regions:

  • us-east-1

  • * us-west-2

  • ap-southeast-2

    *

  • ap-northeast-1

  • * eu-west-1

Your Amazon S3 bucket does not * need to be in these five Regions.

See Also:

AWS * API Reference

*/ virtual Model::SubmitMultiRegionAccessPointRoutesOutcome SubmitMultiRegionAccessPointRoutes(const Model::SubmitMultiRegionAccessPointRoutesRequest& request) const; /** * A Callable wrapper for SubmitMultiRegionAccessPointRoutes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SubmitMultiRegionAccessPointRoutesOutcomeCallable SubmitMultiRegionAccessPointRoutesCallable(const SubmitMultiRegionAccessPointRoutesRequestT& request) const { return SubmitCallable(&S3ControlClient::SubmitMultiRegionAccessPointRoutes, request); } /** * An Async wrapper for SubmitMultiRegionAccessPointRoutes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SubmitMultiRegionAccessPointRoutesAsync(const SubmitMultiRegionAccessPointRoutesRequestT& request, const SubmitMultiRegionAccessPointRoutesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::SubmitMultiRegionAccessPointRoutes, request, handler, context); } /** *

Updates an existing S3 Batch Operations job's priority. For more information, * see S3 * Batch Operations in the Amazon S3 User Guide.

Related * actions include:

See Also:

AWS * API Reference

*/ virtual Model::UpdateJobPriorityOutcome UpdateJobPriority(const Model::UpdateJobPriorityRequest& request) const; /** * A Callable wrapper for UpdateJobPriority that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateJobPriorityOutcomeCallable UpdateJobPriorityCallable(const UpdateJobPriorityRequestT& request) const { return SubmitCallable(&S3ControlClient::UpdateJobPriority, request); } /** * An Async wrapper for UpdateJobPriority that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateJobPriorityAsync(const UpdateJobPriorityRequestT& request, const UpdateJobPriorityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::UpdateJobPriority, request, handler, context); } /** *

Updates the status for the specified job. Use this action to confirm that you * want to run a job or to cancel an existing job. For more information, see S3 * Batch Operations in the Amazon S3 User Guide.

Related * actions include:

See Also:

AWS * API Reference

*/ virtual Model::UpdateJobStatusOutcome UpdateJobStatus(const Model::UpdateJobStatusRequest& request) const; /** * A Callable wrapper for UpdateJobStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateJobStatusOutcomeCallable UpdateJobStatusCallable(const UpdateJobStatusRequestT& request) const { return SubmitCallable(&S3ControlClient::UpdateJobStatus, request); } /** * An Async wrapper for UpdateJobStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateJobStatusAsync(const UpdateJobStatusRequestT& request, const UpdateJobStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&S3ControlClient::UpdateJobStatus, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const S3ControlClientConfiguration& clientConfiguration); S3ControlClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace S3Control } // namespace Aws