/** * 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 namespace Aws { namespace CloudFront { /** * Amazon CloudFront

This is the Amazon CloudFront API * Reference. This guide is for developers who need detailed information about * CloudFront API actions, data types, and errors. For detailed information about * CloudFront features, see the Amazon CloudFront Developer Guide.

*/ class AWS_CLOUDFRONT_API CloudFrontClient : 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 CloudFrontClientConfiguration ClientConfigurationType; typedef CloudFrontEndpointProvider 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. */ CloudFrontClient(const Aws::CloudFront::CloudFrontClientConfiguration& clientConfiguration = Aws::CloudFront::CloudFrontClientConfiguration(), 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. */ CloudFrontClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CloudFront::CloudFrontClientConfiguration& clientConfiguration = Aws::CloudFront::CloudFrontClientConfiguration()); /** * 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 */ CloudFrontClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CloudFront::CloudFrontClientConfiguration& clientConfiguration = Aws::CloudFront::CloudFrontClientConfiguration()); /* 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. */ CloudFrontClient(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. */ CloudFrontClient(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 */ CloudFrontClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~CloudFrontClient(); /** *

Associates an alias (also known as a CNAME or an alternate domain name) with * a CloudFront distribution.

With this operation you can move an alias * that's already in use on a CloudFront distribution to a different distribution * in one step. This prevents the downtime that could occur if you first remove the * alias from one distribution and then separately add the alias to another * distribution.

To use this operation to associate an alias with a * distribution, you provide the alias and the ID of the target distribution for * the alias. For more information, including how to set up the target * distribution, prerequisites that you must complete, and other restrictions, see * Moving * an alternate domain name to a different distribution in the Amazon * CloudFront Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::AssociateAlias2020_05_31Outcome AssociateAlias2020_05_31(const Model::AssociateAlias2020_05_31Request& request) const; /** * A Callable wrapper for AssociateAlias2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateAlias2020_05_31OutcomeCallable AssociateAlias2020_05_31Callable(const AssociateAlias2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::AssociateAlias2020_05_31, request); } /** * An Async wrapper for AssociateAlias2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateAlias2020_05_31Async(const AssociateAlias2020_05_31RequestT& request, const AssociateAlias2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::AssociateAlias2020_05_31, request, handler, context); } /** *

Creates a staging distribution using the configuration of the provided * primary distribution. A staging distribution is a copy of an existing * distribution (called the primary distribution) that you can use in a continuous * deployment workflow.

After you create a staging distribution, you can use * UpdateDistribution to modify the staging distribution's * configuration. Then you can use CreateContinuousDeploymentPolicy to * incrementally move traffic to the staging distribution.

This API * operation requires the following IAM permissions:

See Also:

AWS * API Reference

*/ virtual Model::CopyDistribution2020_05_31Outcome CopyDistribution2020_05_31(const Model::CopyDistribution2020_05_31Request& request) const; /** * A Callable wrapper for CopyDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyDistribution2020_05_31OutcomeCallable CopyDistribution2020_05_31Callable(const CopyDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CopyDistribution2020_05_31, request); } /** * An Async wrapper for CopyDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyDistribution2020_05_31Async(const CopyDistribution2020_05_31RequestT& request, const CopyDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CopyDistribution2020_05_31, request, handler, context); } /** *

Creates a cache policy.

After you create a cache policy, you can * attach it to one or more cache behaviors. When it's attached to a cache * behavior, the cache policy determines the following:

  • The values * that CloudFront includes in the cache key. These values can include HTTP * headers, cookies, and URL query strings. CloudFront uses the cache key to find * an object in its cache that it can return to the viewer.

  • The * default, minimum, and maximum time to live (TTL) values that you want objects to * stay in the CloudFront cache.

The headers, cookies, and query * strings that are included in the cache key are also included in requests that * CloudFront sends to the origin. CloudFront sends a request when it can't find an * object in its cache that matches the request's cache key. If you want to send * values to the origin but not include them in the cache key, use * OriginRequestPolicy.

For more information about cache * policies, see Controlling * the cache key in the Amazon CloudFront Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateCachePolicy2020_05_31Outcome CreateCachePolicy2020_05_31(const Model::CreateCachePolicy2020_05_31Request& request) const; /** * A Callable wrapper for CreateCachePolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCachePolicy2020_05_31OutcomeCallable CreateCachePolicy2020_05_31Callable(const CreateCachePolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateCachePolicy2020_05_31, request); } /** * An Async wrapper for CreateCachePolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCachePolicy2020_05_31Async(const CreateCachePolicy2020_05_31RequestT& request, const CreateCachePolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateCachePolicy2020_05_31, request, handler, context); } /** *

Creates a new origin access identity. If you're using Amazon S3 for your * origin, you can use an origin access identity to require users to access your * content using a CloudFront URL instead of the Amazon S3 URL. For more * information about how to use origin access identities, see Serving * Private Content through CloudFront in the Amazon CloudFront Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateCloudFrontOriginAccessIdentity2020_05_31Outcome CreateCloudFrontOriginAccessIdentity2020_05_31(const Model::CreateCloudFrontOriginAccessIdentity2020_05_31Request& request) const; /** * A Callable wrapper for CreateCloudFrontOriginAccessIdentity2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCloudFrontOriginAccessIdentity2020_05_31OutcomeCallable CreateCloudFrontOriginAccessIdentity2020_05_31Callable(const CreateCloudFrontOriginAccessIdentity2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateCloudFrontOriginAccessIdentity2020_05_31, request); } /** * An Async wrapper for CreateCloudFrontOriginAccessIdentity2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCloudFrontOriginAccessIdentity2020_05_31Async(const CreateCloudFrontOriginAccessIdentity2020_05_31RequestT& request, const CreateCloudFrontOriginAccessIdentity2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateCloudFrontOriginAccessIdentity2020_05_31, request, handler, context); } /** *

Creates a continuous deployment policy that distributes traffic for a custom * domain name to two different CloudFront distributions.

To use a * continuous deployment policy, first use CopyDistribution to create * a staging distribution, then use UpdateDistribution to modify the * staging distribution's configuration.

After you create and update a * staging distribution, you can use a continuous deployment policy to * incrementally move traffic to the staging distribution. This workflow enables * you to test changes to a distribution's configuration before moving all of your * domain's production traffic to the new configuration.

See Also:

* AWS * API Reference

*/ virtual Model::CreateContinuousDeploymentPolicy2020_05_31Outcome CreateContinuousDeploymentPolicy2020_05_31(const Model::CreateContinuousDeploymentPolicy2020_05_31Request& request) const; /** * A Callable wrapper for CreateContinuousDeploymentPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateContinuousDeploymentPolicy2020_05_31OutcomeCallable CreateContinuousDeploymentPolicy2020_05_31Callable(const CreateContinuousDeploymentPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateContinuousDeploymentPolicy2020_05_31, request); } /** * An Async wrapper for CreateContinuousDeploymentPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateContinuousDeploymentPolicy2020_05_31Async(const CreateContinuousDeploymentPolicy2020_05_31RequestT& request, const CreateContinuousDeploymentPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateContinuousDeploymentPolicy2020_05_31, request, handler, context); } /** *

Creates a CloudFront distribution.

See Also:

AWS * API Reference

*/ virtual Model::CreateDistribution2020_05_31Outcome CreateDistribution2020_05_31(const Model::CreateDistribution2020_05_31Request& request) const; /** * A Callable wrapper for CreateDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDistribution2020_05_31OutcomeCallable CreateDistribution2020_05_31Callable(const CreateDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateDistribution2020_05_31, request); } /** * An Async wrapper for CreateDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDistribution2020_05_31Async(const CreateDistribution2020_05_31RequestT& request, const CreateDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateDistribution2020_05_31, request, handler, context); } /** *

Create a new distribution with tags. This API operation requires the * following IAM permissions:

See Also:

AWS * API Reference

*/ virtual Model::CreateDistributionWithTags2020_05_31Outcome CreateDistributionWithTags2020_05_31(const Model::CreateDistributionWithTags2020_05_31Request& request) const; /** * A Callable wrapper for CreateDistributionWithTags2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDistributionWithTags2020_05_31OutcomeCallable CreateDistributionWithTags2020_05_31Callable(const CreateDistributionWithTags2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateDistributionWithTags2020_05_31, request); } /** * An Async wrapper for CreateDistributionWithTags2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDistributionWithTags2020_05_31Async(const CreateDistributionWithTags2020_05_31RequestT& request, const CreateDistributionWithTags2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateDistributionWithTags2020_05_31, request, handler, context); } /** *

Create a new field-level encryption configuration.

See Also:

* AWS * API Reference

*/ virtual Model::CreateFieldLevelEncryptionConfig2020_05_31Outcome CreateFieldLevelEncryptionConfig2020_05_31(const Model::CreateFieldLevelEncryptionConfig2020_05_31Request& request) const; /** * A Callable wrapper for CreateFieldLevelEncryptionConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFieldLevelEncryptionConfig2020_05_31OutcomeCallable CreateFieldLevelEncryptionConfig2020_05_31Callable(const CreateFieldLevelEncryptionConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateFieldLevelEncryptionConfig2020_05_31, request); } /** * An Async wrapper for CreateFieldLevelEncryptionConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFieldLevelEncryptionConfig2020_05_31Async(const CreateFieldLevelEncryptionConfig2020_05_31RequestT& request, const CreateFieldLevelEncryptionConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateFieldLevelEncryptionConfig2020_05_31, request, handler, context); } /** *

Create a field-level encryption profile.

See Also:

AWS * API Reference

*/ virtual Model::CreateFieldLevelEncryptionProfile2020_05_31Outcome CreateFieldLevelEncryptionProfile2020_05_31(const Model::CreateFieldLevelEncryptionProfile2020_05_31Request& request) const; /** * A Callable wrapper for CreateFieldLevelEncryptionProfile2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFieldLevelEncryptionProfile2020_05_31OutcomeCallable CreateFieldLevelEncryptionProfile2020_05_31Callable(const CreateFieldLevelEncryptionProfile2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateFieldLevelEncryptionProfile2020_05_31, request); } /** * An Async wrapper for CreateFieldLevelEncryptionProfile2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFieldLevelEncryptionProfile2020_05_31Async(const CreateFieldLevelEncryptionProfile2020_05_31RequestT& request, const CreateFieldLevelEncryptionProfile2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateFieldLevelEncryptionProfile2020_05_31, request, handler, context); } /** *

Creates a CloudFront function.

To create a function, you provide the * function code and some configuration information about the function. The * response contains an Amazon Resource Name (ARN) that uniquely identifies the * function.

When you create a function, it's in the * DEVELOPMENT stage. In this stage, you can test the function with * TestFunction, and update it with UpdateFunction.

*

When you're ready to use your function with a CloudFront distribution, use * PublishFunction to copy the function from the * DEVELOPMENT stage to LIVE. When it's live, you can * attach the function to a distribution's cache behavior, using the function's * ARN.

See Also:

AWS * API Reference

*/ virtual Model::CreateFunction2020_05_31Outcome CreateFunction2020_05_31(const Model::CreateFunction2020_05_31Request& request) const; /** * A Callable wrapper for CreateFunction2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFunction2020_05_31OutcomeCallable CreateFunction2020_05_31Callable(const CreateFunction2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateFunction2020_05_31, request); } /** * An Async wrapper for CreateFunction2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFunction2020_05_31Async(const CreateFunction2020_05_31RequestT& request, const CreateFunction2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateFunction2020_05_31, request, handler, context); } /** *

Create a new invalidation.

See Also:

AWS * API Reference

*/ virtual Model::CreateInvalidation2020_05_31Outcome CreateInvalidation2020_05_31(const Model::CreateInvalidation2020_05_31Request& request) const; /** * A Callable wrapper for CreateInvalidation2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateInvalidation2020_05_31OutcomeCallable CreateInvalidation2020_05_31Callable(const CreateInvalidation2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateInvalidation2020_05_31, request); } /** * An Async wrapper for CreateInvalidation2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateInvalidation2020_05_31Async(const CreateInvalidation2020_05_31RequestT& request, const CreateInvalidation2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateInvalidation2020_05_31, request, handler, context); } /** *

Creates a key group that you can use with CloudFront * signed URLs and signed cookies.

To create a key group, you must * specify at least one public key for the key group. After you create a key group, * you can reference it from one or more cache behaviors. When you reference a key * group in a cache behavior, CloudFront requires signed URLs or signed cookies for * all requests that match the cache behavior. The URLs or cookies must be signed * with a private key whose corresponding public key is in the key group. The * signed URL or cookie contains information about which public key CloudFront * should use to verify the signature. For more information, see Serving * private content in the Amazon CloudFront Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateKeyGroup2020_05_31Outcome CreateKeyGroup2020_05_31(const Model::CreateKeyGroup2020_05_31Request& request) const; /** * A Callable wrapper for CreateKeyGroup2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateKeyGroup2020_05_31OutcomeCallable CreateKeyGroup2020_05_31Callable(const CreateKeyGroup2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateKeyGroup2020_05_31, request); } /** * An Async wrapper for CreateKeyGroup2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateKeyGroup2020_05_31Async(const CreateKeyGroup2020_05_31RequestT& request, const CreateKeyGroup2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateKeyGroup2020_05_31, request, handler, context); } /** *

Enables additional CloudWatch metrics for the specified CloudFront * distribution. The additional metrics incur an additional cost.

For more * information, see Viewing * additional CloudFront distribution metrics in the Amazon CloudFront * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateMonitoringSubscription2020_05_31Outcome CreateMonitoringSubscription2020_05_31(const Model::CreateMonitoringSubscription2020_05_31Request& request) const; /** * A Callable wrapper for CreateMonitoringSubscription2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateMonitoringSubscription2020_05_31OutcomeCallable CreateMonitoringSubscription2020_05_31Callable(const CreateMonitoringSubscription2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateMonitoringSubscription2020_05_31, request); } /** * An Async wrapper for CreateMonitoringSubscription2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateMonitoringSubscription2020_05_31Async(const CreateMonitoringSubscription2020_05_31RequestT& request, const CreateMonitoringSubscription2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateMonitoringSubscription2020_05_31, request, handler, context); } /** *

Creates a new origin access control in CloudFront. After you create an origin * access control, you can add it to an origin in a CloudFront distribution so that * CloudFront sends authenticated (signed) requests to the origin.

This * makes it possible to block public access to the origin, allowing viewers (users) * to access the origin's content only through CloudFront.

For more * information about using a CloudFront origin access control, see Restricting * access to an Amazon Web Services origin in the Amazon CloudFront * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateOriginAccessControl2020_05_31Outcome CreateOriginAccessControl2020_05_31(const Model::CreateOriginAccessControl2020_05_31Request& request) const; /** * A Callable wrapper for CreateOriginAccessControl2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOriginAccessControl2020_05_31OutcomeCallable CreateOriginAccessControl2020_05_31Callable(const CreateOriginAccessControl2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateOriginAccessControl2020_05_31, request); } /** * An Async wrapper for CreateOriginAccessControl2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOriginAccessControl2020_05_31Async(const CreateOriginAccessControl2020_05_31RequestT& request, const CreateOriginAccessControl2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateOriginAccessControl2020_05_31, request, handler, context); } /** *

Creates an origin request policy.

After you create an origin request * policy, you can attach it to one or more cache behaviors. When it's attached to * a cache behavior, the origin request policy determines the values that * CloudFront includes in requests that it sends to the origin. Each request that * CloudFront sends to the origin includes the following:

  • The * request body and the URL path (without the domain name) from the viewer * request.

  • The headers that CloudFront automatically includes in * every origin request, including Host, User-Agent, and * X-Amz-Cf-Id.

  • All HTTP headers, cookies, and URL * query strings that are specified in the cache policy or the origin request * policy. These can include items from the viewer request and, in the case of * headers, additional ones that are added by CloudFront.

*

CloudFront sends a request when it can't find a valid object in its cache * that matches the request. If you want to send values to the origin and also * include them in the cache key, use CachePolicy.

For more * information about origin request policies, see Controlling * origin requests in the Amazon CloudFront Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateOriginRequestPolicy2020_05_31Outcome CreateOriginRequestPolicy2020_05_31(const Model::CreateOriginRequestPolicy2020_05_31Request& request) const; /** * A Callable wrapper for CreateOriginRequestPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOriginRequestPolicy2020_05_31OutcomeCallable CreateOriginRequestPolicy2020_05_31Callable(const CreateOriginRequestPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateOriginRequestPolicy2020_05_31, request); } /** * An Async wrapper for CreateOriginRequestPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOriginRequestPolicy2020_05_31Async(const CreateOriginRequestPolicy2020_05_31RequestT& request, const CreateOriginRequestPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateOriginRequestPolicy2020_05_31, request, handler, context); } /** *

Uploads a public key to CloudFront that you can use with signed * URLs and signed cookies, or with field-level * encryption.

See Also:

AWS * API Reference

*/ virtual Model::CreatePublicKey2020_05_31Outcome CreatePublicKey2020_05_31(const Model::CreatePublicKey2020_05_31Request& request) const; /** * A Callable wrapper for CreatePublicKey2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePublicKey2020_05_31OutcomeCallable CreatePublicKey2020_05_31Callable(const CreatePublicKey2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreatePublicKey2020_05_31, request); } /** * An Async wrapper for CreatePublicKey2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePublicKey2020_05_31Async(const CreatePublicKey2020_05_31RequestT& request, const CreatePublicKey2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreatePublicKey2020_05_31, request, handler, context); } /** *

Creates a real-time log configuration.

After you create a real-time * log configuration, you can attach it to one or more cache behaviors to send * real-time log data to the specified Amazon Kinesis data stream.

For more * information about real-time log configurations, see Real-time * logs in the Amazon CloudFront Developer Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateRealtimeLogConfig2020_05_31Outcome CreateRealtimeLogConfig2020_05_31(const Model::CreateRealtimeLogConfig2020_05_31Request& request) const; /** * A Callable wrapper for CreateRealtimeLogConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRealtimeLogConfig2020_05_31OutcomeCallable CreateRealtimeLogConfig2020_05_31Callable(const CreateRealtimeLogConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateRealtimeLogConfig2020_05_31, request); } /** * An Async wrapper for CreateRealtimeLogConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRealtimeLogConfig2020_05_31Async(const CreateRealtimeLogConfig2020_05_31RequestT& request, const CreateRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateRealtimeLogConfig2020_05_31, request, handler, context); } /** *

Creates a response headers policy.

A response headers policy contains * information about a set of HTTP headers. To create a response headers policy, * you provide some metadata about the policy and a set of configurations that * specify the headers.

After you create a response headers policy, you can * use its ID to attach it to one or more cache behaviors in a CloudFront * distribution. When it's attached to a cache behavior, the response headers * policy affects the HTTP headers that CloudFront includes in HTTP responses to * requests that match the cache behavior. CloudFront adds or removes response * headers according to the configuration of the response headers policy.

*

For more information, see Adding * or removing HTTP headers in CloudFront responses in the Amazon CloudFront * Developer Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateResponseHeadersPolicy2020_05_31Outcome CreateResponseHeadersPolicy2020_05_31(const Model::CreateResponseHeadersPolicy2020_05_31Request& request) const; /** * A Callable wrapper for CreateResponseHeadersPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateResponseHeadersPolicy2020_05_31OutcomeCallable CreateResponseHeadersPolicy2020_05_31Callable(const CreateResponseHeadersPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateResponseHeadersPolicy2020_05_31, request); } /** * An Async wrapper for CreateResponseHeadersPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateResponseHeadersPolicy2020_05_31Async(const CreateResponseHeadersPolicy2020_05_31RequestT& request, const CreateResponseHeadersPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateResponseHeadersPolicy2020_05_31, request, handler, context); } /** *

This API is deprecated. Amazon CloudFront is deprecating real-time messaging * protocol (RTMP) distributions on December 31, 2020. For more information, read the * announcement on the Amazon CloudFront discussion forum.

See * Also:

AWS * API Reference

*/ virtual Model::CreateStreamingDistribution2020_05_31Outcome CreateStreamingDistribution2020_05_31(const Model::CreateStreamingDistribution2020_05_31Request& request) const; /** * A Callable wrapper for CreateStreamingDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStreamingDistribution2020_05_31OutcomeCallable CreateStreamingDistribution2020_05_31Callable(const CreateStreamingDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateStreamingDistribution2020_05_31, request); } /** * An Async wrapper for CreateStreamingDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStreamingDistribution2020_05_31Async(const CreateStreamingDistribution2020_05_31RequestT& request, const CreateStreamingDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateStreamingDistribution2020_05_31, request, handler, context); } /** *

This API is deprecated. Amazon CloudFront is deprecating real-time messaging * protocol (RTMP) distributions on December 31, 2020. For more information, read the * announcement on the Amazon CloudFront discussion forum.

See * Also:

AWS * API Reference

*/ virtual Model::CreateStreamingDistributionWithTags2020_05_31Outcome CreateStreamingDistributionWithTags2020_05_31(const Model::CreateStreamingDistributionWithTags2020_05_31Request& request) const; /** * A Callable wrapper for CreateStreamingDistributionWithTags2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStreamingDistributionWithTags2020_05_31OutcomeCallable CreateStreamingDistributionWithTags2020_05_31Callable(const CreateStreamingDistributionWithTags2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::CreateStreamingDistributionWithTags2020_05_31, request); } /** * An Async wrapper for CreateStreamingDistributionWithTags2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStreamingDistributionWithTags2020_05_31Async(const CreateStreamingDistributionWithTags2020_05_31RequestT& request, const CreateStreamingDistributionWithTags2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::CreateStreamingDistributionWithTags2020_05_31, request, handler, context); } /** *

Deletes a cache policy.

You cannot delete a cache policy if it's * attached to a cache behavior. First update your distributions to remove the * cache policy from all cache behaviors, then delete the cache policy.

To * delete a cache policy, you must provide the policy's identifier and version. To * get these values, you can use ListCachePolicies or * GetCachePolicy.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCachePolicy2020_05_31Outcome DeleteCachePolicy2020_05_31(const Model::DeleteCachePolicy2020_05_31Request& request) const; /** * A Callable wrapper for DeleteCachePolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCachePolicy2020_05_31OutcomeCallable DeleteCachePolicy2020_05_31Callable(const DeleteCachePolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteCachePolicy2020_05_31, request); } /** * An Async wrapper for DeleteCachePolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCachePolicy2020_05_31Async(const DeleteCachePolicy2020_05_31RequestT& request, const DeleteCachePolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteCachePolicy2020_05_31, request, handler, context); } /** *

Delete an origin access identity.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCloudFrontOriginAccessIdentity2020_05_31Outcome DeleteCloudFrontOriginAccessIdentity2020_05_31(const Model::DeleteCloudFrontOriginAccessIdentity2020_05_31Request& request) const; /** * A Callable wrapper for DeleteCloudFrontOriginAccessIdentity2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCloudFrontOriginAccessIdentity2020_05_31OutcomeCallable DeleteCloudFrontOriginAccessIdentity2020_05_31Callable(const DeleteCloudFrontOriginAccessIdentity2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteCloudFrontOriginAccessIdentity2020_05_31, request); } /** * An Async wrapper for DeleteCloudFrontOriginAccessIdentity2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCloudFrontOriginAccessIdentity2020_05_31Async(const DeleteCloudFrontOriginAccessIdentity2020_05_31RequestT& request, const DeleteCloudFrontOriginAccessIdentity2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteCloudFrontOriginAccessIdentity2020_05_31, request, handler, context); } /** *

Deletes a continuous deployment policy.

You cannot delete a continuous * deployment policy that's attached to a primary distribution. First update your * distribution to remove the continuous deployment policy, then you can delete the * policy.

See Also:

AWS * API Reference

*/ virtual Model::DeleteContinuousDeploymentPolicy2020_05_31Outcome DeleteContinuousDeploymentPolicy2020_05_31(const Model::DeleteContinuousDeploymentPolicy2020_05_31Request& request) const; /** * A Callable wrapper for DeleteContinuousDeploymentPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteContinuousDeploymentPolicy2020_05_31OutcomeCallable DeleteContinuousDeploymentPolicy2020_05_31Callable(const DeleteContinuousDeploymentPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteContinuousDeploymentPolicy2020_05_31, request); } /** * An Async wrapper for DeleteContinuousDeploymentPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteContinuousDeploymentPolicy2020_05_31Async(const DeleteContinuousDeploymentPolicy2020_05_31RequestT& request, const DeleteContinuousDeploymentPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteContinuousDeploymentPolicy2020_05_31, request, handler, context); } /** *

Delete a distribution.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDistribution2020_05_31Outcome DeleteDistribution2020_05_31(const Model::DeleteDistribution2020_05_31Request& request) const; /** * A Callable wrapper for DeleteDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDistribution2020_05_31OutcomeCallable DeleteDistribution2020_05_31Callable(const DeleteDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteDistribution2020_05_31, request); } /** * An Async wrapper for DeleteDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDistribution2020_05_31Async(const DeleteDistribution2020_05_31RequestT& request, const DeleteDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteDistribution2020_05_31, request, handler, context); } /** *

Remove a field-level encryption configuration.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFieldLevelEncryptionConfig2020_05_31Outcome DeleteFieldLevelEncryptionConfig2020_05_31(const Model::DeleteFieldLevelEncryptionConfig2020_05_31Request& request) const; /** * A Callable wrapper for DeleteFieldLevelEncryptionConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFieldLevelEncryptionConfig2020_05_31OutcomeCallable DeleteFieldLevelEncryptionConfig2020_05_31Callable(const DeleteFieldLevelEncryptionConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteFieldLevelEncryptionConfig2020_05_31, request); } /** * An Async wrapper for DeleteFieldLevelEncryptionConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFieldLevelEncryptionConfig2020_05_31Async(const DeleteFieldLevelEncryptionConfig2020_05_31RequestT& request, const DeleteFieldLevelEncryptionConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteFieldLevelEncryptionConfig2020_05_31, request, handler, context); } /** *

Remove a field-level encryption profile.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFieldLevelEncryptionProfile2020_05_31Outcome DeleteFieldLevelEncryptionProfile2020_05_31(const Model::DeleteFieldLevelEncryptionProfile2020_05_31Request& request) const; /** * A Callable wrapper for DeleteFieldLevelEncryptionProfile2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFieldLevelEncryptionProfile2020_05_31OutcomeCallable DeleteFieldLevelEncryptionProfile2020_05_31Callable(const DeleteFieldLevelEncryptionProfile2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteFieldLevelEncryptionProfile2020_05_31, request); } /** * An Async wrapper for DeleteFieldLevelEncryptionProfile2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFieldLevelEncryptionProfile2020_05_31Async(const DeleteFieldLevelEncryptionProfile2020_05_31RequestT& request, const DeleteFieldLevelEncryptionProfile2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteFieldLevelEncryptionProfile2020_05_31, request, handler, context); } /** *

Deletes a CloudFront function.

You cannot delete a function if it's * associated with a cache behavior. First, update your distributions to remove the * function association from all cache behaviors, then delete the function.

*

To delete a function, you must provide the function's name and version * (ETag value). To get these values, you can use * ListFunctions and DescribeFunction.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteFunction2020_05_31Outcome DeleteFunction2020_05_31(const Model::DeleteFunction2020_05_31Request& request) const; /** * A Callable wrapper for DeleteFunction2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFunction2020_05_31OutcomeCallable DeleteFunction2020_05_31Callable(const DeleteFunction2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteFunction2020_05_31, request); } /** * An Async wrapper for DeleteFunction2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFunction2020_05_31Async(const DeleteFunction2020_05_31RequestT& request, const DeleteFunction2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteFunction2020_05_31, request, handler, context); } /** *

Deletes a key group.

You cannot delete a key group that is referenced * in a cache behavior. First update your distributions to remove the key group * from all cache behaviors, then delete the key group.

To delete a key * group, you must provide the key group's identifier and version. To get these * values, use ListKeyGroups followed by GetKeyGroup or * GetKeyGroupConfig.

See Also:

AWS * API Reference

*/ virtual Model::DeleteKeyGroup2020_05_31Outcome DeleteKeyGroup2020_05_31(const Model::DeleteKeyGroup2020_05_31Request& request) const; /** * A Callable wrapper for DeleteKeyGroup2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteKeyGroup2020_05_31OutcomeCallable DeleteKeyGroup2020_05_31Callable(const DeleteKeyGroup2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteKeyGroup2020_05_31, request); } /** * An Async wrapper for DeleteKeyGroup2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteKeyGroup2020_05_31Async(const DeleteKeyGroup2020_05_31RequestT& request, const DeleteKeyGroup2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteKeyGroup2020_05_31, request, handler, context); } /** *

Disables additional CloudWatch metrics for the specified CloudFront * distribution.

See Also:

AWS * API Reference

*/ virtual Model::DeleteMonitoringSubscription2020_05_31Outcome DeleteMonitoringSubscription2020_05_31(const Model::DeleteMonitoringSubscription2020_05_31Request& request) const; /** * A Callable wrapper for DeleteMonitoringSubscription2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteMonitoringSubscription2020_05_31OutcomeCallable DeleteMonitoringSubscription2020_05_31Callable(const DeleteMonitoringSubscription2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteMonitoringSubscription2020_05_31, request); } /** * An Async wrapper for DeleteMonitoringSubscription2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteMonitoringSubscription2020_05_31Async(const DeleteMonitoringSubscription2020_05_31RequestT& request, const DeleteMonitoringSubscription2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteMonitoringSubscription2020_05_31, request, handler, context); } /** *

Deletes a CloudFront origin access control.

You cannot delete an * origin access control if it's in use. First, update all distributions to remove * the origin access control from all origins, then delete the origin access * control.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOriginAccessControl2020_05_31Outcome DeleteOriginAccessControl2020_05_31(const Model::DeleteOriginAccessControl2020_05_31Request& request) const; /** * A Callable wrapper for DeleteOriginAccessControl2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOriginAccessControl2020_05_31OutcomeCallable DeleteOriginAccessControl2020_05_31Callable(const DeleteOriginAccessControl2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteOriginAccessControl2020_05_31, request); } /** * An Async wrapper for DeleteOriginAccessControl2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOriginAccessControl2020_05_31Async(const DeleteOriginAccessControl2020_05_31RequestT& request, const DeleteOriginAccessControl2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteOriginAccessControl2020_05_31, request, handler, context); } /** *

Deletes an origin request policy.

You cannot delete an origin request * policy if it's attached to any cache behaviors. First update your distributions * to remove the origin request policy from all cache behaviors, then delete the * origin request policy.

To delete an origin request policy, you must * provide the policy's identifier and version. To get the identifier, you can use * ListOriginRequestPolicies or * GetOriginRequestPolicy.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOriginRequestPolicy2020_05_31Outcome DeleteOriginRequestPolicy2020_05_31(const Model::DeleteOriginRequestPolicy2020_05_31Request& request) const; /** * A Callable wrapper for DeleteOriginRequestPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOriginRequestPolicy2020_05_31OutcomeCallable DeleteOriginRequestPolicy2020_05_31Callable(const DeleteOriginRequestPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteOriginRequestPolicy2020_05_31, request); } /** * An Async wrapper for DeleteOriginRequestPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOriginRequestPolicy2020_05_31Async(const DeleteOriginRequestPolicy2020_05_31RequestT& request, const DeleteOriginRequestPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteOriginRequestPolicy2020_05_31, request, handler, context); } /** *

Remove a public key you previously added to CloudFront.

See * Also:

AWS * API Reference

*/ virtual Model::DeletePublicKey2020_05_31Outcome DeletePublicKey2020_05_31(const Model::DeletePublicKey2020_05_31Request& request) const; /** * A Callable wrapper for DeletePublicKey2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePublicKey2020_05_31OutcomeCallable DeletePublicKey2020_05_31Callable(const DeletePublicKey2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeletePublicKey2020_05_31, request); } /** * An Async wrapper for DeletePublicKey2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePublicKey2020_05_31Async(const DeletePublicKey2020_05_31RequestT& request, const DeletePublicKey2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeletePublicKey2020_05_31, request, handler, context); } /** *

Deletes a real-time log configuration.

You cannot delete a real-time * log configuration if it's attached to a cache behavior. First update your * distributions to remove the real-time log configuration from all cache * behaviors, then delete the real-time log configuration.

To delete a * real-time log configuration, you can provide the configuration's name or its * Amazon Resource Name (ARN). You must provide at least one. If you provide both, * CloudFront uses the name to identify the real-time log configuration to * delete.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRealtimeLogConfig2020_05_31Outcome DeleteRealtimeLogConfig2020_05_31(const Model::DeleteRealtimeLogConfig2020_05_31Request& request) const; /** * A Callable wrapper for DeleteRealtimeLogConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRealtimeLogConfig2020_05_31OutcomeCallable DeleteRealtimeLogConfig2020_05_31Callable(const DeleteRealtimeLogConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteRealtimeLogConfig2020_05_31, request); } /** * An Async wrapper for DeleteRealtimeLogConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRealtimeLogConfig2020_05_31Async(const DeleteRealtimeLogConfig2020_05_31RequestT& request, const DeleteRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteRealtimeLogConfig2020_05_31, request, handler, context); } /** *

Deletes a response headers policy.

You cannot delete a response * headers policy if it's attached to a cache behavior. First update your * distributions to remove the response headers policy from all cache behaviors, * then delete the response headers policy.

To delete a response headers * policy, you must provide the policy's identifier and version. To get these * values, you can use ListResponseHeadersPolicies or * GetResponseHeadersPolicy.

See Also:

AWS * API Reference

*/ virtual Model::DeleteResponseHeadersPolicy2020_05_31Outcome DeleteResponseHeadersPolicy2020_05_31(const Model::DeleteResponseHeadersPolicy2020_05_31Request& request) const; /** * A Callable wrapper for DeleteResponseHeadersPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteResponseHeadersPolicy2020_05_31OutcomeCallable DeleteResponseHeadersPolicy2020_05_31Callable(const DeleteResponseHeadersPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteResponseHeadersPolicy2020_05_31, request); } /** * An Async wrapper for DeleteResponseHeadersPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteResponseHeadersPolicy2020_05_31Async(const DeleteResponseHeadersPolicy2020_05_31RequestT& request, const DeleteResponseHeadersPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteResponseHeadersPolicy2020_05_31, request, handler, context); } /** *

Delete a streaming distribution. To delete an RTMP distribution using the * CloudFront API, perform the following steps.

To delete an RTMP * distribution using the CloudFront API:

  1. Disable the RTMP * distribution.

  2. Submit a GET Streaming Distribution * Config request to get the current configuration and the Etag * header for the distribution.

  3. Update the XML document that was * returned in the response to your GET Streaming Distribution Config * request to change the value of Enabled to false.

    *

  4. Submit a PUT Streaming Distribution Config request to * update the configuration for your distribution. In the request body, include the * XML document that you updated in Step 3. Then set the value of the HTTP * If-Match header to the value of the ETag header that * CloudFront returned when you submitted the GET Streaming Distribution * Config request in Step 2.

  5. Review the response to the * PUT Streaming Distribution Config request to confirm that the * distribution was successfully disabled.

  6. Submit a GET * Streaming Distribution Config request to confirm that your changes have * propagated. When propagation is complete, the value of Status is * Deployed.

  7. Submit a DELETE Streaming * Distribution request. Set the value of the HTTP If-Match * header to the value of the ETag header that CloudFront returned * when you submitted the GET Streaming Distribution Config request in * Step 2.

  8. Review the response to your DELETE Streaming * Distribution request to confirm that the distribution was successfully * deleted.

For information about deleting a distribution using * the CloudFront console, see Deleting * a Distribution in the Amazon CloudFront Developer * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStreamingDistribution2020_05_31Outcome DeleteStreamingDistribution2020_05_31(const Model::DeleteStreamingDistribution2020_05_31Request& request) const; /** * A Callable wrapper for DeleteStreamingDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStreamingDistribution2020_05_31OutcomeCallable DeleteStreamingDistribution2020_05_31Callable(const DeleteStreamingDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DeleteStreamingDistribution2020_05_31, request); } /** * An Async wrapper for DeleteStreamingDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStreamingDistribution2020_05_31Async(const DeleteStreamingDistribution2020_05_31RequestT& request, const DeleteStreamingDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DeleteStreamingDistribution2020_05_31, request, handler, context); } /** *

Gets configuration information and metadata about a CloudFront function, but * not the function's code. To get a function's code, use * GetFunction.

To get configuration information and metadata * about a function, you must provide the function's name and stage. To get these * values, you can use ListFunctions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFunction2020_05_31Outcome DescribeFunction2020_05_31(const Model::DescribeFunction2020_05_31Request& request) const; /** * A Callable wrapper for DescribeFunction2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFunction2020_05_31OutcomeCallable DescribeFunction2020_05_31Callable(const DescribeFunction2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::DescribeFunction2020_05_31, request); } /** * An Async wrapper for DescribeFunction2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFunction2020_05_31Async(const DescribeFunction2020_05_31RequestT& request, const DescribeFunction2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::DescribeFunction2020_05_31, request, handler, context); } /** *

Gets a cache policy, including the following metadata:

  • The * policy's identifier.

  • The date and time when the policy was * last modified.

To get a cache policy, you must provide the * policy's identifier. If the cache policy is attached to a distribution's cache * behavior, you can get the policy's identifier using * ListDistributions or GetDistribution. If the cache * policy is not attached to a cache behavior, you can get the identifier using * ListCachePolicies.

See Also:

AWS * API Reference

*/ virtual Model::GetCachePolicy2020_05_31Outcome GetCachePolicy2020_05_31(const Model::GetCachePolicy2020_05_31Request& request) const; /** * A Callable wrapper for GetCachePolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCachePolicy2020_05_31OutcomeCallable GetCachePolicy2020_05_31Callable(const GetCachePolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetCachePolicy2020_05_31, request); } /** * An Async wrapper for GetCachePolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCachePolicy2020_05_31Async(const GetCachePolicy2020_05_31RequestT& request, const GetCachePolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetCachePolicy2020_05_31, request, handler, context); } /** *

Gets a cache policy configuration.

To get a cache policy * configuration, you must provide the policy's identifier. If the cache policy is * attached to a distribution's cache behavior, you can get the policy's identifier * using ListDistributions or GetDistribution. If the * cache policy is not attached to a cache behavior, you can get the identifier * using ListCachePolicies.

See Also:

AWS * API Reference

*/ virtual Model::GetCachePolicyConfig2020_05_31Outcome GetCachePolicyConfig2020_05_31(const Model::GetCachePolicyConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetCachePolicyConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCachePolicyConfig2020_05_31OutcomeCallable GetCachePolicyConfig2020_05_31Callable(const GetCachePolicyConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetCachePolicyConfig2020_05_31, request); } /** * An Async wrapper for GetCachePolicyConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCachePolicyConfig2020_05_31Async(const GetCachePolicyConfig2020_05_31RequestT& request, const GetCachePolicyConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetCachePolicyConfig2020_05_31, request, handler, context); } /** *

Get the information about an origin access identity.

See Also:

* AWS * API Reference

*/ virtual Model::GetCloudFrontOriginAccessIdentity2020_05_31Outcome GetCloudFrontOriginAccessIdentity2020_05_31(const Model::GetCloudFrontOriginAccessIdentity2020_05_31Request& request) const; /** * A Callable wrapper for GetCloudFrontOriginAccessIdentity2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCloudFrontOriginAccessIdentity2020_05_31OutcomeCallable GetCloudFrontOriginAccessIdentity2020_05_31Callable(const GetCloudFrontOriginAccessIdentity2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetCloudFrontOriginAccessIdentity2020_05_31, request); } /** * An Async wrapper for GetCloudFrontOriginAccessIdentity2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCloudFrontOriginAccessIdentity2020_05_31Async(const GetCloudFrontOriginAccessIdentity2020_05_31RequestT& request, const GetCloudFrontOriginAccessIdentity2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetCloudFrontOriginAccessIdentity2020_05_31, request, handler, context); } /** *

Get the configuration information about an origin access * identity.

See Also:

AWS * API Reference

*/ virtual Model::GetCloudFrontOriginAccessIdentityConfig2020_05_31Outcome GetCloudFrontOriginAccessIdentityConfig2020_05_31(const Model::GetCloudFrontOriginAccessIdentityConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetCloudFrontOriginAccessIdentityConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCloudFrontOriginAccessIdentityConfig2020_05_31OutcomeCallable GetCloudFrontOriginAccessIdentityConfig2020_05_31Callable(const GetCloudFrontOriginAccessIdentityConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetCloudFrontOriginAccessIdentityConfig2020_05_31, request); } /** * An Async wrapper for GetCloudFrontOriginAccessIdentityConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCloudFrontOriginAccessIdentityConfig2020_05_31Async(const GetCloudFrontOriginAccessIdentityConfig2020_05_31RequestT& request, const GetCloudFrontOriginAccessIdentityConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetCloudFrontOriginAccessIdentityConfig2020_05_31, request, handler, context); } /** *

Gets a continuous deployment policy, including metadata (the policy's * identifier and the date and time when the policy was last * modified).

See Also:

AWS * API Reference

*/ virtual Model::GetContinuousDeploymentPolicy2020_05_31Outcome GetContinuousDeploymentPolicy2020_05_31(const Model::GetContinuousDeploymentPolicy2020_05_31Request& request) const; /** * A Callable wrapper for GetContinuousDeploymentPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContinuousDeploymentPolicy2020_05_31OutcomeCallable GetContinuousDeploymentPolicy2020_05_31Callable(const GetContinuousDeploymentPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetContinuousDeploymentPolicy2020_05_31, request); } /** * An Async wrapper for GetContinuousDeploymentPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContinuousDeploymentPolicy2020_05_31Async(const GetContinuousDeploymentPolicy2020_05_31RequestT& request, const GetContinuousDeploymentPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetContinuousDeploymentPolicy2020_05_31, request, handler, context); } /** *

Gets configuration information about a continuous deployment * policy.

See Also:

AWS * API Reference

*/ virtual Model::GetContinuousDeploymentPolicyConfig2020_05_31Outcome GetContinuousDeploymentPolicyConfig2020_05_31(const Model::GetContinuousDeploymentPolicyConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetContinuousDeploymentPolicyConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetContinuousDeploymentPolicyConfig2020_05_31OutcomeCallable GetContinuousDeploymentPolicyConfig2020_05_31Callable(const GetContinuousDeploymentPolicyConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetContinuousDeploymentPolicyConfig2020_05_31, request); } /** * An Async wrapper for GetContinuousDeploymentPolicyConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetContinuousDeploymentPolicyConfig2020_05_31Async(const GetContinuousDeploymentPolicyConfig2020_05_31RequestT& request, const GetContinuousDeploymentPolicyConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetContinuousDeploymentPolicyConfig2020_05_31, request, handler, context); } /** *

Get the information about a distribution.

See Also:

AWS * API Reference

*/ virtual Model::GetDistribution2020_05_31Outcome GetDistribution2020_05_31(const Model::GetDistribution2020_05_31Request& request) const; /** * A Callable wrapper for GetDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDistribution2020_05_31OutcomeCallable GetDistribution2020_05_31Callable(const GetDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetDistribution2020_05_31, request); } /** * An Async wrapper for GetDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDistribution2020_05_31Async(const GetDistribution2020_05_31RequestT& request, const GetDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetDistribution2020_05_31, request, handler, context); } /** *

Get the configuration information about a distribution.

See * Also:

AWS * API Reference

*/ virtual Model::GetDistributionConfig2020_05_31Outcome GetDistributionConfig2020_05_31(const Model::GetDistributionConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetDistributionConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDistributionConfig2020_05_31OutcomeCallable GetDistributionConfig2020_05_31Callable(const GetDistributionConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetDistributionConfig2020_05_31, request); } /** * An Async wrapper for GetDistributionConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDistributionConfig2020_05_31Async(const GetDistributionConfig2020_05_31RequestT& request, const GetDistributionConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetDistributionConfig2020_05_31, request, handler, context); } /** *

Get the field-level encryption configuration information.

See * Also:

AWS * API Reference

*/ virtual Model::GetFieldLevelEncryption2020_05_31Outcome GetFieldLevelEncryption2020_05_31(const Model::GetFieldLevelEncryption2020_05_31Request& request) const; /** * A Callable wrapper for GetFieldLevelEncryption2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFieldLevelEncryption2020_05_31OutcomeCallable GetFieldLevelEncryption2020_05_31Callable(const GetFieldLevelEncryption2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetFieldLevelEncryption2020_05_31, request); } /** * An Async wrapper for GetFieldLevelEncryption2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFieldLevelEncryption2020_05_31Async(const GetFieldLevelEncryption2020_05_31RequestT& request, const GetFieldLevelEncryption2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetFieldLevelEncryption2020_05_31, request, handler, context); } /** *

Get the field-level encryption configuration information.

See * Also:

AWS * API Reference

*/ virtual Model::GetFieldLevelEncryptionConfig2020_05_31Outcome GetFieldLevelEncryptionConfig2020_05_31(const Model::GetFieldLevelEncryptionConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetFieldLevelEncryptionConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFieldLevelEncryptionConfig2020_05_31OutcomeCallable GetFieldLevelEncryptionConfig2020_05_31Callable(const GetFieldLevelEncryptionConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetFieldLevelEncryptionConfig2020_05_31, request); } /** * An Async wrapper for GetFieldLevelEncryptionConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFieldLevelEncryptionConfig2020_05_31Async(const GetFieldLevelEncryptionConfig2020_05_31RequestT& request, const GetFieldLevelEncryptionConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetFieldLevelEncryptionConfig2020_05_31, request, handler, context); } /** *

Get the field-level encryption profile information.

See Also:

* AWS * API Reference

*/ virtual Model::GetFieldLevelEncryptionProfile2020_05_31Outcome GetFieldLevelEncryptionProfile2020_05_31(const Model::GetFieldLevelEncryptionProfile2020_05_31Request& request) const; /** * A Callable wrapper for GetFieldLevelEncryptionProfile2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFieldLevelEncryptionProfile2020_05_31OutcomeCallable GetFieldLevelEncryptionProfile2020_05_31Callable(const GetFieldLevelEncryptionProfile2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetFieldLevelEncryptionProfile2020_05_31, request); } /** * An Async wrapper for GetFieldLevelEncryptionProfile2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFieldLevelEncryptionProfile2020_05_31Async(const GetFieldLevelEncryptionProfile2020_05_31RequestT& request, const GetFieldLevelEncryptionProfile2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetFieldLevelEncryptionProfile2020_05_31, request, handler, context); } /** *

Get the field-level encryption profile configuration * information.

See Also:

AWS * API Reference

*/ virtual Model::GetFieldLevelEncryptionProfileConfig2020_05_31Outcome GetFieldLevelEncryptionProfileConfig2020_05_31(const Model::GetFieldLevelEncryptionProfileConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetFieldLevelEncryptionProfileConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFieldLevelEncryptionProfileConfig2020_05_31OutcomeCallable GetFieldLevelEncryptionProfileConfig2020_05_31Callable(const GetFieldLevelEncryptionProfileConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetFieldLevelEncryptionProfileConfig2020_05_31, request); } /** * An Async wrapper for GetFieldLevelEncryptionProfileConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFieldLevelEncryptionProfileConfig2020_05_31Async(const GetFieldLevelEncryptionProfileConfig2020_05_31RequestT& request, const GetFieldLevelEncryptionProfileConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetFieldLevelEncryptionProfileConfig2020_05_31, request, handler, context); } /** *

Gets the code of a CloudFront function. To get configuration information and * metadata about a function, use DescribeFunction.

To get a * function's code, you must provide the function's name and stage. To get these * values, you can use ListFunctions.

See Also:

AWS * API Reference

*/ virtual Model::GetFunction2020_05_31Outcome GetFunction2020_05_31(const Model::GetFunction2020_05_31Request& request) const; /** * A Callable wrapper for GetFunction2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFunction2020_05_31OutcomeCallable GetFunction2020_05_31Callable(const GetFunction2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetFunction2020_05_31, request); } /** * An Async wrapper for GetFunction2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFunction2020_05_31Async(const GetFunction2020_05_31RequestT& request, const GetFunction2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetFunction2020_05_31, request, handler, context); } /** *

Get the information about an invalidation.

See Also:

AWS * API Reference

*/ virtual Model::GetInvalidation2020_05_31Outcome GetInvalidation2020_05_31(const Model::GetInvalidation2020_05_31Request& request) const; /** * A Callable wrapper for GetInvalidation2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetInvalidation2020_05_31OutcomeCallable GetInvalidation2020_05_31Callable(const GetInvalidation2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetInvalidation2020_05_31, request); } /** * An Async wrapper for GetInvalidation2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetInvalidation2020_05_31Async(const GetInvalidation2020_05_31RequestT& request, const GetInvalidation2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetInvalidation2020_05_31, request, handler, context); } /** *

Gets a key group, including the date and time when the key group was last * modified.

To get a key group, you must provide the key group's * identifier. If the key group is referenced in a distribution's cache behavior, * you can get the key group's identifier using ListDistributions or * GetDistribution. If the key group is not referenced in a cache * behavior, you can get the identifier using * ListKeyGroups.

See Also:

AWS * API Reference

*/ virtual Model::GetKeyGroup2020_05_31Outcome GetKeyGroup2020_05_31(const Model::GetKeyGroup2020_05_31Request& request) const; /** * A Callable wrapper for GetKeyGroup2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetKeyGroup2020_05_31OutcomeCallable GetKeyGroup2020_05_31Callable(const GetKeyGroup2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetKeyGroup2020_05_31, request); } /** * An Async wrapper for GetKeyGroup2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetKeyGroup2020_05_31Async(const GetKeyGroup2020_05_31RequestT& request, const GetKeyGroup2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetKeyGroup2020_05_31, request, handler, context); } /** *

Gets a key group configuration.

To get a key group configuration, you * must provide the key group's identifier. If the key group is referenced in a * distribution's cache behavior, you can get the key group's identifier using * ListDistributions or GetDistribution. If the key group * is not referenced in a cache behavior, you can get the identifier using * ListKeyGroups.

See Also:

AWS * API Reference

*/ virtual Model::GetKeyGroupConfig2020_05_31Outcome GetKeyGroupConfig2020_05_31(const Model::GetKeyGroupConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetKeyGroupConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetKeyGroupConfig2020_05_31OutcomeCallable GetKeyGroupConfig2020_05_31Callable(const GetKeyGroupConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetKeyGroupConfig2020_05_31, request); } /** * An Async wrapper for GetKeyGroupConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetKeyGroupConfig2020_05_31Async(const GetKeyGroupConfig2020_05_31RequestT& request, const GetKeyGroupConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetKeyGroupConfig2020_05_31, request, handler, context); } /** *

Gets information about whether additional CloudWatch metrics are enabled for * the specified CloudFront distribution.

See Also:

AWS * API Reference

*/ virtual Model::GetMonitoringSubscription2020_05_31Outcome GetMonitoringSubscription2020_05_31(const Model::GetMonitoringSubscription2020_05_31Request& request) const; /** * A Callable wrapper for GetMonitoringSubscription2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMonitoringSubscription2020_05_31OutcomeCallable GetMonitoringSubscription2020_05_31Callable(const GetMonitoringSubscription2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetMonitoringSubscription2020_05_31, request); } /** * An Async wrapper for GetMonitoringSubscription2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMonitoringSubscription2020_05_31Async(const GetMonitoringSubscription2020_05_31RequestT& request, const GetMonitoringSubscription2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetMonitoringSubscription2020_05_31, request, handler, context); } /** *

Gets a CloudFront origin access control, including its unique * identifier.

See Also:

AWS * API Reference

*/ virtual Model::GetOriginAccessControl2020_05_31Outcome GetOriginAccessControl2020_05_31(const Model::GetOriginAccessControl2020_05_31Request& request) const; /** * A Callable wrapper for GetOriginAccessControl2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOriginAccessControl2020_05_31OutcomeCallable GetOriginAccessControl2020_05_31Callable(const GetOriginAccessControl2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetOriginAccessControl2020_05_31, request); } /** * An Async wrapper for GetOriginAccessControl2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOriginAccessControl2020_05_31Async(const GetOriginAccessControl2020_05_31RequestT& request, const GetOriginAccessControl2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetOriginAccessControl2020_05_31, request, handler, context); } /** *

Gets a CloudFront origin access control configuration.

See * Also:

AWS * API Reference

*/ virtual Model::GetOriginAccessControlConfig2020_05_31Outcome GetOriginAccessControlConfig2020_05_31(const Model::GetOriginAccessControlConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetOriginAccessControlConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOriginAccessControlConfig2020_05_31OutcomeCallable GetOriginAccessControlConfig2020_05_31Callable(const GetOriginAccessControlConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetOriginAccessControlConfig2020_05_31, request); } /** * An Async wrapper for GetOriginAccessControlConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOriginAccessControlConfig2020_05_31Async(const GetOriginAccessControlConfig2020_05_31RequestT& request, const GetOriginAccessControlConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetOriginAccessControlConfig2020_05_31, request, handler, context); } /** *

Gets an origin request policy, including the following metadata:

    *

  • The policy's identifier.

  • The date and time when the * policy was last modified.

To get an origin request policy, * you must provide the policy's identifier. If the origin request policy is * attached to a distribution's cache behavior, you can get the policy's identifier * using ListDistributions or GetDistribution. If the * origin request policy is not attached to a cache behavior, you can get the * identifier using ListOriginRequestPolicies.

See * Also:

AWS * API Reference

*/ virtual Model::GetOriginRequestPolicy2020_05_31Outcome GetOriginRequestPolicy2020_05_31(const Model::GetOriginRequestPolicy2020_05_31Request& request) const; /** * A Callable wrapper for GetOriginRequestPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOriginRequestPolicy2020_05_31OutcomeCallable GetOriginRequestPolicy2020_05_31Callable(const GetOriginRequestPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetOriginRequestPolicy2020_05_31, request); } /** * An Async wrapper for GetOriginRequestPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOriginRequestPolicy2020_05_31Async(const GetOriginRequestPolicy2020_05_31RequestT& request, const GetOriginRequestPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetOriginRequestPolicy2020_05_31, request, handler, context); } /** *

Gets an origin request policy configuration.

To get an origin request * policy configuration, you must provide the policy's identifier. If the origin * request policy is attached to a distribution's cache behavior, you can get the * policy's identifier using ListDistributions or * GetDistribution. If the origin request policy is not attached to a * cache behavior, you can get the identifier using * ListOriginRequestPolicies.

See Also:

AWS * API Reference

*/ virtual Model::GetOriginRequestPolicyConfig2020_05_31Outcome GetOriginRequestPolicyConfig2020_05_31(const Model::GetOriginRequestPolicyConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetOriginRequestPolicyConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetOriginRequestPolicyConfig2020_05_31OutcomeCallable GetOriginRequestPolicyConfig2020_05_31Callable(const GetOriginRequestPolicyConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetOriginRequestPolicyConfig2020_05_31, request); } /** * An Async wrapper for GetOriginRequestPolicyConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetOriginRequestPolicyConfig2020_05_31Async(const GetOriginRequestPolicyConfig2020_05_31RequestT& request, const GetOriginRequestPolicyConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetOriginRequestPolicyConfig2020_05_31, request, handler, context); } /** *

Gets a public key.

See Also:

AWS * API Reference

*/ virtual Model::GetPublicKey2020_05_31Outcome GetPublicKey2020_05_31(const Model::GetPublicKey2020_05_31Request& request) const; /** * A Callable wrapper for GetPublicKey2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPublicKey2020_05_31OutcomeCallable GetPublicKey2020_05_31Callable(const GetPublicKey2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetPublicKey2020_05_31, request); } /** * An Async wrapper for GetPublicKey2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPublicKey2020_05_31Async(const GetPublicKey2020_05_31RequestT& request, const GetPublicKey2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetPublicKey2020_05_31, request, handler, context); } /** *

Gets a public key configuration.

See Also:

AWS * API Reference

*/ virtual Model::GetPublicKeyConfig2020_05_31Outcome GetPublicKeyConfig2020_05_31(const Model::GetPublicKeyConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetPublicKeyConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPublicKeyConfig2020_05_31OutcomeCallable GetPublicKeyConfig2020_05_31Callable(const GetPublicKeyConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetPublicKeyConfig2020_05_31, request); } /** * An Async wrapper for GetPublicKeyConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPublicKeyConfig2020_05_31Async(const GetPublicKeyConfig2020_05_31RequestT& request, const GetPublicKeyConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetPublicKeyConfig2020_05_31, request, handler, context); } /** *

Gets a real-time log configuration.

To get a real-time log * configuration, you can provide the configuration's name or its Amazon Resource * Name (ARN). You must provide at least one. If you provide both, CloudFront uses * the name to identify the real-time log configuration to get.

See * Also:

AWS * API Reference

*/ virtual Model::GetRealtimeLogConfig2020_05_31Outcome GetRealtimeLogConfig2020_05_31(const Model::GetRealtimeLogConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetRealtimeLogConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRealtimeLogConfig2020_05_31OutcomeCallable GetRealtimeLogConfig2020_05_31Callable(const GetRealtimeLogConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetRealtimeLogConfig2020_05_31, request); } /** * An Async wrapper for GetRealtimeLogConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRealtimeLogConfig2020_05_31Async(const GetRealtimeLogConfig2020_05_31RequestT& request, const GetRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetRealtimeLogConfig2020_05_31, request, handler, context); } /** *

Gets a response headers policy, including metadata (the policy's identifier * and the date and time when the policy was last modified).

To get a * response headers policy, you must provide the policy's identifier. If the * response headers policy is attached to a distribution's cache behavior, you can * get the policy's identifier using ListDistributions or * GetDistribution. If the response headers policy is not attached to * a cache behavior, you can get the identifier using * ListResponseHeadersPolicies.

See Also:

AWS * API Reference

*/ virtual Model::GetResponseHeadersPolicy2020_05_31Outcome GetResponseHeadersPolicy2020_05_31(const Model::GetResponseHeadersPolicy2020_05_31Request& request) const; /** * A Callable wrapper for GetResponseHeadersPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResponseHeadersPolicy2020_05_31OutcomeCallable GetResponseHeadersPolicy2020_05_31Callable(const GetResponseHeadersPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetResponseHeadersPolicy2020_05_31, request); } /** * An Async wrapper for GetResponseHeadersPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResponseHeadersPolicy2020_05_31Async(const GetResponseHeadersPolicy2020_05_31RequestT& request, const GetResponseHeadersPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetResponseHeadersPolicy2020_05_31, request, handler, context); } /** *

Gets a response headers policy configuration.

To get a response * headers policy configuration, you must provide the policy's identifier. If the * response headers policy is attached to a distribution's cache behavior, you can * get the policy's identifier using ListDistributions or * GetDistribution. If the response headers policy is not attached to * a cache behavior, you can get the identifier using * ListResponseHeadersPolicies.

See Also:

AWS * API Reference

*/ virtual Model::GetResponseHeadersPolicyConfig2020_05_31Outcome GetResponseHeadersPolicyConfig2020_05_31(const Model::GetResponseHeadersPolicyConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetResponseHeadersPolicyConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResponseHeadersPolicyConfig2020_05_31OutcomeCallable GetResponseHeadersPolicyConfig2020_05_31Callable(const GetResponseHeadersPolicyConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetResponseHeadersPolicyConfig2020_05_31, request); } /** * An Async wrapper for GetResponseHeadersPolicyConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResponseHeadersPolicyConfig2020_05_31Async(const GetResponseHeadersPolicyConfig2020_05_31RequestT& request, const GetResponseHeadersPolicyConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetResponseHeadersPolicyConfig2020_05_31, request, handler, context); } /** *

Gets information about a specified RTMP distribution, including the * distribution configuration.

See Also:

AWS * API Reference

*/ virtual Model::GetStreamingDistribution2020_05_31Outcome GetStreamingDistribution2020_05_31(const Model::GetStreamingDistribution2020_05_31Request& request) const; /** * A Callable wrapper for GetStreamingDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStreamingDistribution2020_05_31OutcomeCallable GetStreamingDistribution2020_05_31Callable(const GetStreamingDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetStreamingDistribution2020_05_31, request); } /** * An Async wrapper for GetStreamingDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStreamingDistribution2020_05_31Async(const GetStreamingDistribution2020_05_31RequestT& request, const GetStreamingDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetStreamingDistribution2020_05_31, request, handler, context); } /** *

Get the configuration information about a streaming * distribution.

See Also:

AWS * API Reference

*/ virtual Model::GetStreamingDistributionConfig2020_05_31Outcome GetStreamingDistributionConfig2020_05_31(const Model::GetStreamingDistributionConfig2020_05_31Request& request) const; /** * A Callable wrapper for GetStreamingDistributionConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetStreamingDistributionConfig2020_05_31OutcomeCallable GetStreamingDistributionConfig2020_05_31Callable(const GetStreamingDistributionConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::GetStreamingDistributionConfig2020_05_31, request); } /** * An Async wrapper for GetStreamingDistributionConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetStreamingDistributionConfig2020_05_31Async(const GetStreamingDistributionConfig2020_05_31RequestT& request, const GetStreamingDistributionConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::GetStreamingDistributionConfig2020_05_31, request, handler, context); } /** *

Gets a list of cache policies.

You can optionally apply a filter to * return only the managed policies created by Amazon Web Services, or only the * custom policies created in your Amazon Web Services account.

You can * optionally specify the maximum number of items to receive in the response. If * the total number of items in the list exceeds the maximum that you specify, or * the default maximum, the response is paginated. To get the next page of items, * send a subsequent request that specifies the NextMarker value from * the current response as the Marker value in the subsequent * request.

See Also:

AWS * API Reference

*/ virtual Model::ListCachePolicies2020_05_31Outcome ListCachePolicies2020_05_31(const Model::ListCachePolicies2020_05_31Request& request) const; /** * A Callable wrapper for ListCachePolicies2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCachePolicies2020_05_31OutcomeCallable ListCachePolicies2020_05_31Callable(const ListCachePolicies2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListCachePolicies2020_05_31, request); } /** * An Async wrapper for ListCachePolicies2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCachePolicies2020_05_31Async(const ListCachePolicies2020_05_31RequestT& request, const ListCachePolicies2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListCachePolicies2020_05_31, request, handler, context); } /** *

Lists origin access identities.

See Also:

AWS * API Reference

*/ virtual Model::ListCloudFrontOriginAccessIdentities2020_05_31Outcome ListCloudFrontOriginAccessIdentities2020_05_31(const Model::ListCloudFrontOriginAccessIdentities2020_05_31Request& request) const; /** * A Callable wrapper for ListCloudFrontOriginAccessIdentities2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListCloudFrontOriginAccessIdentities2020_05_31OutcomeCallable ListCloudFrontOriginAccessIdentities2020_05_31Callable(const ListCloudFrontOriginAccessIdentities2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListCloudFrontOriginAccessIdentities2020_05_31, request); } /** * An Async wrapper for ListCloudFrontOriginAccessIdentities2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListCloudFrontOriginAccessIdentities2020_05_31Async(const ListCloudFrontOriginAccessIdentities2020_05_31RequestT& request, const ListCloudFrontOriginAccessIdentities2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListCloudFrontOriginAccessIdentities2020_05_31, request, handler, context); } /** *

Gets a list of aliases (also called CNAMEs or alternate domain names) that * conflict or overlap with the provided alias, and the associated CloudFront * distributions and Amazon Web Services accounts for each conflicting alias. In * the returned list, the distribution and account IDs are partially hidden, which * allows you to identify the distributions and accounts that you own, but helps to * protect the information of ones that you don't own.

Use this operation to * find aliases that are in use in CloudFront that conflict or overlap with the * provided alias. For example, if you provide www.example.com as * input, the returned list can include www.example.com and the * overlapping wildcard alternate domain name (*.example.com), if they * exist. If you provide *.example.com as input, the returned list can * include *.example.com and any alternate domain names covered by * that wildcard (for example, www.example.com, * test.example.com, dev.example.com, and so on), if they * exist.

To list conflicting aliases, you provide the alias to search and * the ID of a distribution in your account that has an attached SSL/TLS * certificate that includes the provided alias. For more information, including * how to set up the distribution and certificate, see Moving * an alternate domain name to a different distribution in the Amazon * CloudFront Developer Guide.

You can optionally specify the maximum * number of items to receive in the response. If the total number of items in the * list exceeds the maximum that you specify, or the default maximum, the response * is paginated. To get the next page of items, send a subsequent request that * specifies the NextMarker value from the current response as the * Marker value in the subsequent request.

See Also:

* AWS * API Reference

*/ virtual Model::ListConflictingAliases2020_05_31Outcome ListConflictingAliases2020_05_31(const Model::ListConflictingAliases2020_05_31Request& request) const; /** * A Callable wrapper for ListConflictingAliases2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListConflictingAliases2020_05_31OutcomeCallable ListConflictingAliases2020_05_31Callable(const ListConflictingAliases2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListConflictingAliases2020_05_31, request); } /** * An Async wrapper for ListConflictingAliases2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListConflictingAliases2020_05_31Async(const ListConflictingAliases2020_05_31RequestT& request, const ListConflictingAliases2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListConflictingAliases2020_05_31, request, handler, context); } /** *

Gets a list of the continuous deployment policies in your Amazon Web Services * account.

You can optionally specify the maximum number of items to * receive in the response. If the total number of items in the list exceeds the * maximum that you specify, or the default maximum, the response is paginated. To * get the next page of items, send a subsequent request that specifies the * NextMarker value from the current response as the * Marker value in the subsequent request.

See Also:

* AWS * API Reference

*/ virtual Model::ListContinuousDeploymentPolicies2020_05_31Outcome ListContinuousDeploymentPolicies2020_05_31(const Model::ListContinuousDeploymentPolicies2020_05_31Request& request) const; /** * A Callable wrapper for ListContinuousDeploymentPolicies2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListContinuousDeploymentPolicies2020_05_31OutcomeCallable ListContinuousDeploymentPolicies2020_05_31Callable(const ListContinuousDeploymentPolicies2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListContinuousDeploymentPolicies2020_05_31, request); } /** * An Async wrapper for ListContinuousDeploymentPolicies2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListContinuousDeploymentPolicies2020_05_31Async(const ListContinuousDeploymentPolicies2020_05_31RequestT& request, const ListContinuousDeploymentPolicies2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListContinuousDeploymentPolicies2020_05_31, request, handler, context); } /** *

List CloudFront distributions.

See Also:

AWS * API Reference

*/ virtual Model::ListDistributions2020_05_31Outcome ListDistributions2020_05_31(const Model::ListDistributions2020_05_31Request& request) const; /** * A Callable wrapper for ListDistributions2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDistributions2020_05_31OutcomeCallable ListDistributions2020_05_31Callable(const ListDistributions2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListDistributions2020_05_31, request); } /** * An Async wrapper for ListDistributions2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDistributions2020_05_31Async(const ListDistributions2020_05_31RequestT& request, const ListDistributions2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListDistributions2020_05_31, request, handler, context); } /** *

Gets a list of distribution IDs for distributions that have a cache behavior * that's associated with the specified cache policy.

You can optionally * specify the maximum number of items to receive in the response. If the total * number of items in the list exceeds the maximum that you specify, or the default * maximum, the response is paginated. To get the next page of items, send a * subsequent request that specifies the NextMarker value from the * current response as the Marker value in the subsequent * request.

See Also:

AWS * API Reference

*/ virtual Model::ListDistributionsByCachePolicyId2020_05_31Outcome ListDistributionsByCachePolicyId2020_05_31(const Model::ListDistributionsByCachePolicyId2020_05_31Request& request) const; /** * A Callable wrapper for ListDistributionsByCachePolicyId2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDistributionsByCachePolicyId2020_05_31OutcomeCallable ListDistributionsByCachePolicyId2020_05_31Callable(const ListDistributionsByCachePolicyId2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListDistributionsByCachePolicyId2020_05_31, request); } /** * An Async wrapper for ListDistributionsByCachePolicyId2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDistributionsByCachePolicyId2020_05_31Async(const ListDistributionsByCachePolicyId2020_05_31RequestT& request, const ListDistributionsByCachePolicyId2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListDistributionsByCachePolicyId2020_05_31, request, handler, context); } /** *

Gets a list of distribution IDs for distributions that have a cache behavior * that references the specified key group.

You can optionally specify the * maximum number of items to receive in the response. If the total number of items * in the list exceeds the maximum that you specify, or the default maximum, the * response is paginated. To get the next page of items, send a subsequent request * that specifies the NextMarker value from the current response as * the Marker value in the subsequent request.

See * Also:

AWS * API Reference

*/ virtual Model::ListDistributionsByKeyGroup2020_05_31Outcome ListDistributionsByKeyGroup2020_05_31(const Model::ListDistributionsByKeyGroup2020_05_31Request& request) const; /** * A Callable wrapper for ListDistributionsByKeyGroup2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDistributionsByKeyGroup2020_05_31OutcomeCallable ListDistributionsByKeyGroup2020_05_31Callable(const ListDistributionsByKeyGroup2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListDistributionsByKeyGroup2020_05_31, request); } /** * An Async wrapper for ListDistributionsByKeyGroup2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDistributionsByKeyGroup2020_05_31Async(const ListDistributionsByKeyGroup2020_05_31RequestT& request, const ListDistributionsByKeyGroup2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListDistributionsByKeyGroup2020_05_31, request, handler, context); } /** *

Gets a list of distribution IDs for distributions that have a cache behavior * that's associated with the specified origin request policy.

You can * optionally specify the maximum number of items to receive in the response. If * the total number of items in the list exceeds the maximum that you specify, or * the default maximum, the response is paginated. To get the next page of items, * send a subsequent request that specifies the NextMarker value from * the current response as the Marker value in the subsequent * request.

See Also:

AWS * API Reference

*/ virtual Model::ListDistributionsByOriginRequestPolicyId2020_05_31Outcome ListDistributionsByOriginRequestPolicyId2020_05_31(const Model::ListDistributionsByOriginRequestPolicyId2020_05_31Request& request) const; /** * A Callable wrapper for ListDistributionsByOriginRequestPolicyId2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDistributionsByOriginRequestPolicyId2020_05_31OutcomeCallable ListDistributionsByOriginRequestPolicyId2020_05_31Callable(const ListDistributionsByOriginRequestPolicyId2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListDistributionsByOriginRequestPolicyId2020_05_31, request); } /** * An Async wrapper for ListDistributionsByOriginRequestPolicyId2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDistributionsByOriginRequestPolicyId2020_05_31Async(const ListDistributionsByOriginRequestPolicyId2020_05_31RequestT& request, const ListDistributionsByOriginRequestPolicyId2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListDistributionsByOriginRequestPolicyId2020_05_31, request, handler, context); } /** *

Gets a list of distributions that have a cache behavior that's associated * with the specified real-time log configuration.

You can specify the * real-time log configuration by its name or its Amazon Resource Name (ARN). You * must provide at least one. If you provide both, CloudFront uses the name to * identify the real-time log configuration to list distributions for.

You * can optionally specify the maximum number of items to receive in the response. * If the total number of items in the list exceeds the maximum that you specify, * or the default maximum, the response is paginated. To get the next page of * items, send a subsequent request that specifies the NextMarker * value from the current response as the Marker value in the * subsequent request.

See Also:

AWS * API Reference

*/ virtual Model::ListDistributionsByRealtimeLogConfig2020_05_31Outcome ListDistributionsByRealtimeLogConfig2020_05_31(const Model::ListDistributionsByRealtimeLogConfig2020_05_31Request& request) const; /** * A Callable wrapper for ListDistributionsByRealtimeLogConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDistributionsByRealtimeLogConfig2020_05_31OutcomeCallable ListDistributionsByRealtimeLogConfig2020_05_31Callable(const ListDistributionsByRealtimeLogConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListDistributionsByRealtimeLogConfig2020_05_31, request); } /** * An Async wrapper for ListDistributionsByRealtimeLogConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDistributionsByRealtimeLogConfig2020_05_31Async(const ListDistributionsByRealtimeLogConfig2020_05_31RequestT& request, const ListDistributionsByRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListDistributionsByRealtimeLogConfig2020_05_31, request, handler, context); } /** *

Gets a list of distribution IDs for distributions that have a cache behavior * that's associated with the specified response headers policy.

You can * optionally specify the maximum number of items to receive in the response. If * the total number of items in the list exceeds the maximum that you specify, or * the default maximum, the response is paginated. To get the next page of items, * send a subsequent request that specifies the NextMarker value from * the current response as the Marker value in the subsequent * request.

See Also:

AWS * API Reference

*/ virtual Model::ListDistributionsByResponseHeadersPolicyId2020_05_31Outcome ListDistributionsByResponseHeadersPolicyId2020_05_31(const Model::ListDistributionsByResponseHeadersPolicyId2020_05_31Request& request) const; /** * A Callable wrapper for ListDistributionsByResponseHeadersPolicyId2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDistributionsByResponseHeadersPolicyId2020_05_31OutcomeCallable ListDistributionsByResponseHeadersPolicyId2020_05_31Callable(const ListDistributionsByResponseHeadersPolicyId2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListDistributionsByResponseHeadersPolicyId2020_05_31, request); } /** * An Async wrapper for ListDistributionsByResponseHeadersPolicyId2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDistributionsByResponseHeadersPolicyId2020_05_31Async(const ListDistributionsByResponseHeadersPolicyId2020_05_31RequestT& request, const ListDistributionsByResponseHeadersPolicyId2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListDistributionsByResponseHeadersPolicyId2020_05_31, request, handler, context); } /** *

List the distributions that are associated with a specified WAF web * ACL.

See Also:

AWS * API Reference

*/ virtual Model::ListDistributionsByWebACLId2020_05_31Outcome ListDistributionsByWebACLId2020_05_31(const Model::ListDistributionsByWebACLId2020_05_31Request& request) const; /** * A Callable wrapper for ListDistributionsByWebACLId2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDistributionsByWebACLId2020_05_31OutcomeCallable ListDistributionsByWebACLId2020_05_31Callable(const ListDistributionsByWebACLId2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListDistributionsByWebACLId2020_05_31, request); } /** * An Async wrapper for ListDistributionsByWebACLId2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDistributionsByWebACLId2020_05_31Async(const ListDistributionsByWebACLId2020_05_31RequestT& request, const ListDistributionsByWebACLId2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListDistributionsByWebACLId2020_05_31, request, handler, context); } /** *

List all field-level encryption configurations that have been created in * CloudFront for this account.

See Also:

AWS * API Reference

*/ virtual Model::ListFieldLevelEncryptionConfigs2020_05_31Outcome ListFieldLevelEncryptionConfigs2020_05_31(const Model::ListFieldLevelEncryptionConfigs2020_05_31Request& request) const; /** * A Callable wrapper for ListFieldLevelEncryptionConfigs2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFieldLevelEncryptionConfigs2020_05_31OutcomeCallable ListFieldLevelEncryptionConfigs2020_05_31Callable(const ListFieldLevelEncryptionConfigs2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListFieldLevelEncryptionConfigs2020_05_31, request); } /** * An Async wrapper for ListFieldLevelEncryptionConfigs2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFieldLevelEncryptionConfigs2020_05_31Async(const ListFieldLevelEncryptionConfigs2020_05_31RequestT& request, const ListFieldLevelEncryptionConfigs2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListFieldLevelEncryptionConfigs2020_05_31, request, handler, context); } /** *

Request a list of field-level encryption profiles that have been created in * CloudFront for this account.

See Also:

AWS * API Reference

*/ virtual Model::ListFieldLevelEncryptionProfiles2020_05_31Outcome ListFieldLevelEncryptionProfiles2020_05_31(const Model::ListFieldLevelEncryptionProfiles2020_05_31Request& request) const; /** * A Callable wrapper for ListFieldLevelEncryptionProfiles2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFieldLevelEncryptionProfiles2020_05_31OutcomeCallable ListFieldLevelEncryptionProfiles2020_05_31Callable(const ListFieldLevelEncryptionProfiles2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListFieldLevelEncryptionProfiles2020_05_31, request); } /** * An Async wrapper for ListFieldLevelEncryptionProfiles2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFieldLevelEncryptionProfiles2020_05_31Async(const ListFieldLevelEncryptionProfiles2020_05_31RequestT& request, const ListFieldLevelEncryptionProfiles2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListFieldLevelEncryptionProfiles2020_05_31, request, handler, context); } /** *

Gets a list of all CloudFront functions in your Amazon Web Services * account.

You can optionally apply a filter to return only the functions * that are in the specified stage, either DEVELOPMENT or * LIVE.

You can optionally specify the maximum number of items * to receive in the response. If the total number of items in the list exceeds the * maximum that you specify, or the default maximum, the response is paginated. To * get the next page of items, send a subsequent request that specifies the * NextMarker value from the current response as the * Marker value in the subsequent request.

See Also:

* AWS * API Reference

*/ virtual Model::ListFunctions2020_05_31Outcome ListFunctions2020_05_31(const Model::ListFunctions2020_05_31Request& request) const; /** * A Callable wrapper for ListFunctions2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListFunctions2020_05_31OutcomeCallable ListFunctions2020_05_31Callable(const ListFunctions2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListFunctions2020_05_31, request); } /** * An Async wrapper for ListFunctions2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListFunctions2020_05_31Async(const ListFunctions2020_05_31RequestT& request, const ListFunctions2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListFunctions2020_05_31, request, handler, context); } /** *

Lists invalidation batches.

See Also:

AWS * API Reference

*/ virtual Model::ListInvalidations2020_05_31Outcome ListInvalidations2020_05_31(const Model::ListInvalidations2020_05_31Request& request) const; /** * A Callable wrapper for ListInvalidations2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListInvalidations2020_05_31OutcomeCallable ListInvalidations2020_05_31Callable(const ListInvalidations2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListInvalidations2020_05_31, request); } /** * An Async wrapper for ListInvalidations2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListInvalidations2020_05_31Async(const ListInvalidations2020_05_31RequestT& request, const ListInvalidations2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListInvalidations2020_05_31, request, handler, context); } /** *

Gets a list of key groups.

You can optionally specify the maximum * number of items to receive in the response. If the total number of items in the * list exceeds the maximum that you specify, or the default maximum, the response * is paginated. To get the next page of items, send a subsequent request that * specifies the NextMarker value from the current response as the * Marker value in the subsequent request.

See Also:

* AWS * API Reference

*/ virtual Model::ListKeyGroups2020_05_31Outcome ListKeyGroups2020_05_31(const Model::ListKeyGroups2020_05_31Request& request) const; /** * A Callable wrapper for ListKeyGroups2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListKeyGroups2020_05_31OutcomeCallable ListKeyGroups2020_05_31Callable(const ListKeyGroups2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListKeyGroups2020_05_31, request); } /** * An Async wrapper for ListKeyGroups2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListKeyGroups2020_05_31Async(const ListKeyGroups2020_05_31RequestT& request, const ListKeyGroups2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListKeyGroups2020_05_31, request, handler, context); } /** *

Gets the list of CloudFront origin access controls in this Amazon Web * Services account.

You can optionally specify the maximum number of items * to receive in the response. If the total number of items in the list exceeds the * maximum that you specify, or the default maximum, the response is paginated. To * get the next page of items, send another request that specifies the * NextMarker value from the current response as the * Marker value in the next request.

See Also:

AWS * API Reference

*/ virtual Model::ListOriginAccessControls2020_05_31Outcome ListOriginAccessControls2020_05_31(const Model::ListOriginAccessControls2020_05_31Request& request) const; /** * A Callable wrapper for ListOriginAccessControls2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOriginAccessControls2020_05_31OutcomeCallable ListOriginAccessControls2020_05_31Callable(const ListOriginAccessControls2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListOriginAccessControls2020_05_31, request); } /** * An Async wrapper for ListOriginAccessControls2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOriginAccessControls2020_05_31Async(const ListOriginAccessControls2020_05_31RequestT& request, const ListOriginAccessControls2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListOriginAccessControls2020_05_31, request, handler, context); } /** *

Gets a list of origin request policies.

You can optionally apply a * filter to return only the managed policies created by Amazon Web Services, or * only the custom policies created in your Amazon Web Services account.

You * can optionally specify the maximum number of items to receive in the response. * If the total number of items in the list exceeds the maximum that you specify, * or the default maximum, the response is paginated. To get the next page of * items, send a subsequent request that specifies the NextMarker * value from the current response as the Marker value in the * subsequent request.

See Also:

AWS * API Reference

*/ virtual Model::ListOriginRequestPolicies2020_05_31Outcome ListOriginRequestPolicies2020_05_31(const Model::ListOriginRequestPolicies2020_05_31Request& request) const; /** * A Callable wrapper for ListOriginRequestPolicies2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListOriginRequestPolicies2020_05_31OutcomeCallable ListOriginRequestPolicies2020_05_31Callable(const ListOriginRequestPolicies2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListOriginRequestPolicies2020_05_31, request); } /** * An Async wrapper for ListOriginRequestPolicies2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListOriginRequestPolicies2020_05_31Async(const ListOriginRequestPolicies2020_05_31RequestT& request, const ListOriginRequestPolicies2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListOriginRequestPolicies2020_05_31, request, handler, context); } /** *

List all public keys that have been added to CloudFront for this * account.

See Also:

AWS * API Reference

*/ virtual Model::ListPublicKeys2020_05_31Outcome ListPublicKeys2020_05_31(const Model::ListPublicKeys2020_05_31Request& request) const; /** * A Callable wrapper for ListPublicKeys2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPublicKeys2020_05_31OutcomeCallable ListPublicKeys2020_05_31Callable(const ListPublicKeys2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListPublicKeys2020_05_31, request); } /** * An Async wrapper for ListPublicKeys2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPublicKeys2020_05_31Async(const ListPublicKeys2020_05_31RequestT& request, const ListPublicKeys2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListPublicKeys2020_05_31, request, handler, context); } /** *

Gets a list of real-time log configurations.

You can optionally * specify the maximum number of items to receive in the response. If the total * number of items in the list exceeds the maximum that you specify, or the default * maximum, the response is paginated. To get the next page of items, send a * subsequent request that specifies the NextMarker value from the * current response as the Marker value in the subsequent * request.

See Also:

AWS * API Reference

*/ virtual Model::ListRealtimeLogConfigs2020_05_31Outcome ListRealtimeLogConfigs2020_05_31(const Model::ListRealtimeLogConfigs2020_05_31Request& request) const; /** * A Callable wrapper for ListRealtimeLogConfigs2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRealtimeLogConfigs2020_05_31OutcomeCallable ListRealtimeLogConfigs2020_05_31Callable(const ListRealtimeLogConfigs2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListRealtimeLogConfigs2020_05_31, request); } /** * An Async wrapper for ListRealtimeLogConfigs2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRealtimeLogConfigs2020_05_31Async(const ListRealtimeLogConfigs2020_05_31RequestT& request, const ListRealtimeLogConfigs2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListRealtimeLogConfigs2020_05_31, request, handler, context); } /** *

Gets a list of response headers policies.

You can optionally apply a * filter to get only the managed policies created by Amazon Web Services, or only * the custom policies created in your Amazon Web Services account.

You can * optionally specify the maximum number of items to receive in the response. If * the total number of items in the list exceeds the maximum that you specify, or * the default maximum, the response is paginated. To get the next page of items, * send a subsequent request that specifies the NextMarker value from * the current response as the Marker value in the subsequent * request.

See Also:

AWS * API Reference

*/ virtual Model::ListResponseHeadersPolicies2020_05_31Outcome ListResponseHeadersPolicies2020_05_31(const Model::ListResponseHeadersPolicies2020_05_31Request& request) const; /** * A Callable wrapper for ListResponseHeadersPolicies2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListResponseHeadersPolicies2020_05_31OutcomeCallable ListResponseHeadersPolicies2020_05_31Callable(const ListResponseHeadersPolicies2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListResponseHeadersPolicies2020_05_31, request); } /** * An Async wrapper for ListResponseHeadersPolicies2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListResponseHeadersPolicies2020_05_31Async(const ListResponseHeadersPolicies2020_05_31RequestT& request, const ListResponseHeadersPolicies2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListResponseHeadersPolicies2020_05_31, request, handler, context); } /** *

List streaming distributions.

See Also:

AWS * API Reference

*/ virtual Model::ListStreamingDistributions2020_05_31Outcome ListStreamingDistributions2020_05_31(const Model::ListStreamingDistributions2020_05_31Request& request) const; /** * A Callable wrapper for ListStreamingDistributions2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListStreamingDistributions2020_05_31OutcomeCallable ListStreamingDistributions2020_05_31Callable(const ListStreamingDistributions2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListStreamingDistributions2020_05_31, request); } /** * An Async wrapper for ListStreamingDistributions2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListStreamingDistributions2020_05_31Async(const ListStreamingDistributions2020_05_31RequestT& request, const ListStreamingDistributions2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListStreamingDistributions2020_05_31, request, handler, context); } /** *

List tags for a CloudFront resource.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResource2020_05_31Outcome ListTagsForResource2020_05_31(const Model::ListTagsForResource2020_05_31Request& request) const; /** * A Callable wrapper for ListTagsForResource2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResource2020_05_31OutcomeCallable ListTagsForResource2020_05_31Callable(const ListTagsForResource2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::ListTagsForResource2020_05_31, request); } /** * An Async wrapper for ListTagsForResource2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResource2020_05_31Async(const ListTagsForResource2020_05_31RequestT& request, const ListTagsForResource2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::ListTagsForResource2020_05_31, request, handler, context); } /** *

Publishes a CloudFront function by copying the function code from the * DEVELOPMENT stage to LIVE. This automatically updates * all cache behaviors that are using this function to use the newly published copy * in the LIVE stage.

When a function is published to the * LIVE stage, you can attach the function to a distribution's cache * behavior, using the function's Amazon Resource Name (ARN).

To publish a * function, you must provide the function's name and version (ETag * value). To get these values, you can use ListFunctions and * DescribeFunction.

See Also:

AWS * API Reference

*/ virtual Model::PublishFunction2020_05_31Outcome PublishFunction2020_05_31(const Model::PublishFunction2020_05_31Request& request) const; /** * A Callable wrapper for PublishFunction2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PublishFunction2020_05_31OutcomeCallable PublishFunction2020_05_31Callable(const PublishFunction2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::PublishFunction2020_05_31, request); } /** * An Async wrapper for PublishFunction2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PublishFunction2020_05_31Async(const PublishFunction2020_05_31RequestT& request, const PublishFunction2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::PublishFunction2020_05_31, request, handler, context); } /** *

Add tags to a CloudFront resource.

See Also:

AWS * API Reference

*/ virtual Model::TagResource2020_05_31Outcome TagResource2020_05_31(const Model::TagResource2020_05_31Request& request) const; /** * A Callable wrapper for TagResource2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResource2020_05_31OutcomeCallable TagResource2020_05_31Callable(const TagResource2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::TagResource2020_05_31, request); } /** * An Async wrapper for TagResource2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResource2020_05_31Async(const TagResource2020_05_31RequestT& request, const TagResource2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::TagResource2020_05_31, request, handler, context); } /** *

Tests a CloudFront function.

To test a function, you provide an * event object that represents an HTTP request or response that your * CloudFront distribution could receive in production. CloudFront runs the * function, passing it the event object that you provided, and returns the * function's result (the modified event object) in the response. The response also * contains function logs and error messages, if any exist. For more information * about testing functions, see Testing * functions in the Amazon CloudFront Developer Guide.

To test a * function, you provide the function's name and version (ETag value) * along with the event object. To get the function's name and version, you can use * ListFunctions and DescribeFunction.

See * Also:

AWS * API Reference

*/ virtual Model::TestFunction2020_05_31Outcome TestFunction2020_05_31(const Model::TestFunction2020_05_31Request& request) const; /** * A Callable wrapper for TestFunction2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestFunction2020_05_31OutcomeCallable TestFunction2020_05_31Callable(const TestFunction2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::TestFunction2020_05_31, request); } /** * An Async wrapper for TestFunction2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestFunction2020_05_31Async(const TestFunction2020_05_31RequestT& request, const TestFunction2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::TestFunction2020_05_31, request, handler, context); } /** *

Remove tags from a CloudFront resource.

See Also:

AWS * API Reference

*/ virtual Model::UntagResource2020_05_31Outcome UntagResource2020_05_31(const Model::UntagResource2020_05_31Request& request) const; /** * A Callable wrapper for UntagResource2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResource2020_05_31OutcomeCallable UntagResource2020_05_31Callable(const UntagResource2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UntagResource2020_05_31, request); } /** * An Async wrapper for UntagResource2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResource2020_05_31Async(const UntagResource2020_05_31RequestT& request, const UntagResource2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UntagResource2020_05_31, request, handler, context); } /** *

Updates a cache policy configuration.

When you update a cache policy * configuration, all the fields are updated with the values provided in the * request. You cannot update some fields independent of others. To update a cache * policy configuration:

  1. Use GetCachePolicyConfig to * get the current configuration.

  2. Locally modify the fields in * the cache policy configuration that you want to update.

  3. Call * UpdateCachePolicy by providing the entire cache policy * configuration, including the fields that you modified and those that you * didn't.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCachePolicy2020_05_31Outcome UpdateCachePolicy2020_05_31(const Model::UpdateCachePolicy2020_05_31Request& request) const; /** * A Callable wrapper for UpdateCachePolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCachePolicy2020_05_31OutcomeCallable UpdateCachePolicy2020_05_31Callable(const UpdateCachePolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateCachePolicy2020_05_31, request); } /** * An Async wrapper for UpdateCachePolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCachePolicy2020_05_31Async(const UpdateCachePolicy2020_05_31RequestT& request, const UpdateCachePolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateCachePolicy2020_05_31, request, handler, context); } /** *

Update an origin access identity.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCloudFrontOriginAccessIdentity2020_05_31Outcome UpdateCloudFrontOriginAccessIdentity2020_05_31(const Model::UpdateCloudFrontOriginAccessIdentity2020_05_31Request& request) const; /** * A Callable wrapper for UpdateCloudFrontOriginAccessIdentity2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCloudFrontOriginAccessIdentity2020_05_31OutcomeCallable UpdateCloudFrontOriginAccessIdentity2020_05_31Callable(const UpdateCloudFrontOriginAccessIdentity2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateCloudFrontOriginAccessIdentity2020_05_31, request); } /** * An Async wrapper for UpdateCloudFrontOriginAccessIdentity2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCloudFrontOriginAccessIdentity2020_05_31Async(const UpdateCloudFrontOriginAccessIdentity2020_05_31RequestT& request, const UpdateCloudFrontOriginAccessIdentity2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateCloudFrontOriginAccessIdentity2020_05_31, request, handler, context); } /** *

Updates a continuous deployment policy. You can update a continuous * deployment policy to enable or disable it, to change the percentage of traffic * that it sends to the staging distribution, or to change the staging distribution * that it sends traffic to.

When you update a continuous deployment policy * configuration, all the fields are updated with the values that are provided in * the request. You cannot update some fields independent of others. To update a * continuous deployment policy configuration:

  1. Use * GetContinuousDeploymentPolicyConfig to get the current * configuration.

  2. Locally modify the fields in the continuous * deployment policy configuration that you want to update.

  3. Use * UpdateContinuousDeploymentPolicy, providing the entire continuous * deployment policy configuration, including the fields that you modified and * those that you didn't.

See Also:

AWS * API Reference

*/ virtual Model::UpdateContinuousDeploymentPolicy2020_05_31Outcome UpdateContinuousDeploymentPolicy2020_05_31(const Model::UpdateContinuousDeploymentPolicy2020_05_31Request& request) const; /** * A Callable wrapper for UpdateContinuousDeploymentPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateContinuousDeploymentPolicy2020_05_31OutcomeCallable UpdateContinuousDeploymentPolicy2020_05_31Callable(const UpdateContinuousDeploymentPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateContinuousDeploymentPolicy2020_05_31, request); } /** * An Async wrapper for UpdateContinuousDeploymentPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateContinuousDeploymentPolicy2020_05_31Async(const UpdateContinuousDeploymentPolicy2020_05_31RequestT& request, const UpdateContinuousDeploymentPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateContinuousDeploymentPolicy2020_05_31, request, handler, context); } /** *

Updates the configuration for a CloudFront distribution.

The update * process includes getting the current distribution configuration, updating it to * make your changes, and then submitting an UpdateDistribution * request to make the updates.

To update a web distribution using the * CloudFront API

  1. Use GetDistributionConfig to * get the current configuration, including the version identifier * (ETag).

  2. Update the distribution configuration * that was returned in the response. Note the following important requirements and * restrictions:

    • You must rename the ETag field to * IfMatch, leaving the value unchanged. (Set the value of * IfMatch to the value of ETag, then remove the * ETag field.)

    • You can't change the value of * CallerReference.

  3. Submit an * UpdateDistribution request, providing the distribution * configuration. The new configuration replaces the existing configuration. The * values that you specify in an UpdateDistribution request are not * merged into your existing configuration. Make sure to include all fields: the * ones that you modified and also the ones that you didn't.

    4. *

See Also:

AWS * API Reference

*/ virtual Model::UpdateDistribution2020_05_31Outcome UpdateDistribution2020_05_31(const Model::UpdateDistribution2020_05_31Request& request) const; /** * A Callable wrapper for UpdateDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDistribution2020_05_31OutcomeCallable UpdateDistribution2020_05_31Callable(const UpdateDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateDistribution2020_05_31, request); } /** * An Async wrapper for UpdateDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDistribution2020_05_31Async(const UpdateDistribution2020_05_31RequestT& request, const UpdateDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateDistribution2020_05_31, request, handler, context); } /** *

Copies the staging distribution's configuration to its corresponding primary * distribution. The primary distribution retains its Aliases (also * known as alternate domain names or CNAMEs) and * ContinuousDeploymentPolicyId value, but otherwise its configuration * is overwritten to match the staging distribution.

You can use this * operation in a continuous deployment workflow after you have tested * configuration changes on the staging distribution. After using a continuous * deployment policy to move a portion of your domain name's traffic to the staging * distribution and verifying that it works as intended, you can use this operation * to copy the staging distribution's configuration to the primary distribution. * This action will disable the continuous deployment policy and move your domain's * traffic back to the primary distribution.

This API operation requires the * following IAM permissions:

See Also:

AWS * API Reference

*/ virtual Model::UpdateDistributionWithStagingConfig2020_05_31Outcome UpdateDistributionWithStagingConfig2020_05_31(const Model::UpdateDistributionWithStagingConfig2020_05_31Request& request) const; /** * A Callable wrapper for UpdateDistributionWithStagingConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDistributionWithStagingConfig2020_05_31OutcomeCallable UpdateDistributionWithStagingConfig2020_05_31Callable(const UpdateDistributionWithStagingConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateDistributionWithStagingConfig2020_05_31, request); } /** * An Async wrapper for UpdateDistributionWithStagingConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDistributionWithStagingConfig2020_05_31Async(const UpdateDistributionWithStagingConfig2020_05_31RequestT& request, const UpdateDistributionWithStagingConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateDistributionWithStagingConfig2020_05_31, request, handler, context); } /** *

Update a field-level encryption configuration.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFieldLevelEncryptionConfig2020_05_31Outcome UpdateFieldLevelEncryptionConfig2020_05_31(const Model::UpdateFieldLevelEncryptionConfig2020_05_31Request& request) const; /** * A Callable wrapper for UpdateFieldLevelEncryptionConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFieldLevelEncryptionConfig2020_05_31OutcomeCallable UpdateFieldLevelEncryptionConfig2020_05_31Callable(const UpdateFieldLevelEncryptionConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateFieldLevelEncryptionConfig2020_05_31, request); } /** * An Async wrapper for UpdateFieldLevelEncryptionConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFieldLevelEncryptionConfig2020_05_31Async(const UpdateFieldLevelEncryptionConfig2020_05_31RequestT& request, const UpdateFieldLevelEncryptionConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateFieldLevelEncryptionConfig2020_05_31, request, handler, context); } /** *

Update a field-level encryption profile.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFieldLevelEncryptionProfile2020_05_31Outcome UpdateFieldLevelEncryptionProfile2020_05_31(const Model::UpdateFieldLevelEncryptionProfile2020_05_31Request& request) const; /** * A Callable wrapper for UpdateFieldLevelEncryptionProfile2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFieldLevelEncryptionProfile2020_05_31OutcomeCallable UpdateFieldLevelEncryptionProfile2020_05_31Callable(const UpdateFieldLevelEncryptionProfile2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateFieldLevelEncryptionProfile2020_05_31, request); } /** * An Async wrapper for UpdateFieldLevelEncryptionProfile2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFieldLevelEncryptionProfile2020_05_31Async(const UpdateFieldLevelEncryptionProfile2020_05_31RequestT& request, const UpdateFieldLevelEncryptionProfile2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateFieldLevelEncryptionProfile2020_05_31, request, handler, context); } /** *

Updates a CloudFront function.

You can update a function's code or the * comment that describes the function. You cannot update a function's name.

*

To update a function, you provide the function's name and version * (ETag value) along with the updated function code. To get the name * and version, you can use ListFunctions and * DescribeFunction.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFunction2020_05_31Outcome UpdateFunction2020_05_31(const Model::UpdateFunction2020_05_31Request& request) const; /** * A Callable wrapper for UpdateFunction2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFunction2020_05_31OutcomeCallable UpdateFunction2020_05_31Callable(const UpdateFunction2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateFunction2020_05_31, request); } /** * An Async wrapper for UpdateFunction2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFunction2020_05_31Async(const UpdateFunction2020_05_31RequestT& request, const UpdateFunction2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateFunction2020_05_31, request, handler, context); } /** *

Updates a key group.

When you update a key group, all the fields are * updated with the values provided in the request. You cannot update some fields * independent of others. To update a key group:

  1. Get the current * key group with GetKeyGroup or GetKeyGroupConfig.

    *

  2. Locally modify the fields in the key group that you want to * update. For example, add or remove public key IDs.

  3. Call * UpdateKeyGroup with the entire key group object, including the * fields that you modified and those that you didn't.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateKeyGroup2020_05_31Outcome UpdateKeyGroup2020_05_31(const Model::UpdateKeyGroup2020_05_31Request& request) const; /** * A Callable wrapper for UpdateKeyGroup2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateKeyGroup2020_05_31OutcomeCallable UpdateKeyGroup2020_05_31Callable(const UpdateKeyGroup2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateKeyGroup2020_05_31, request); } /** * An Async wrapper for UpdateKeyGroup2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateKeyGroup2020_05_31Async(const UpdateKeyGroup2020_05_31RequestT& request, const UpdateKeyGroup2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateKeyGroup2020_05_31, request, handler, context); } /** *

Updates a CloudFront origin access control.

See Also:

AWS * API Reference

*/ virtual Model::UpdateOriginAccessControl2020_05_31Outcome UpdateOriginAccessControl2020_05_31(const Model::UpdateOriginAccessControl2020_05_31Request& request) const; /** * A Callable wrapper for UpdateOriginAccessControl2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateOriginAccessControl2020_05_31OutcomeCallable UpdateOriginAccessControl2020_05_31Callable(const UpdateOriginAccessControl2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateOriginAccessControl2020_05_31, request); } /** * An Async wrapper for UpdateOriginAccessControl2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateOriginAccessControl2020_05_31Async(const UpdateOriginAccessControl2020_05_31RequestT& request, const UpdateOriginAccessControl2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateOriginAccessControl2020_05_31, request, handler, context); } /** *

Updates an origin request policy configuration.

When you update an * origin request policy configuration, all the fields are updated with the values * provided in the request. You cannot update some fields independent of others. To * update an origin request policy configuration:

  1. Use * GetOriginRequestPolicyConfig to get the current configuration.

    *

  2. Locally modify the fields in the origin request policy * configuration that you want to update.

  3. Call * UpdateOriginRequestPolicy by providing the entire origin request * policy configuration, including the fields that you modified and those that you * didn't.

See Also:

AWS * API Reference

*/ virtual Model::UpdateOriginRequestPolicy2020_05_31Outcome UpdateOriginRequestPolicy2020_05_31(const Model::UpdateOriginRequestPolicy2020_05_31Request& request) const; /** * A Callable wrapper for UpdateOriginRequestPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateOriginRequestPolicy2020_05_31OutcomeCallable UpdateOriginRequestPolicy2020_05_31Callable(const UpdateOriginRequestPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateOriginRequestPolicy2020_05_31, request); } /** * An Async wrapper for UpdateOriginRequestPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateOriginRequestPolicy2020_05_31Async(const UpdateOriginRequestPolicy2020_05_31RequestT& request, const UpdateOriginRequestPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateOriginRequestPolicy2020_05_31, request, handler, context); } /** *

Update public key information. Note that the only value you can change is the * comment.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePublicKey2020_05_31Outcome UpdatePublicKey2020_05_31(const Model::UpdatePublicKey2020_05_31Request& request) const; /** * A Callable wrapper for UpdatePublicKey2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePublicKey2020_05_31OutcomeCallable UpdatePublicKey2020_05_31Callable(const UpdatePublicKey2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdatePublicKey2020_05_31, request); } /** * An Async wrapper for UpdatePublicKey2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePublicKey2020_05_31Async(const UpdatePublicKey2020_05_31RequestT& request, const UpdatePublicKey2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdatePublicKey2020_05_31, request, handler, context); } /** *

Updates a real-time log configuration.

When you update a real-time log * configuration, all the parameters are updated with the values provided in the * request. You cannot update some parameters independent of others. To update a * real-time log configuration:

  1. Call * GetRealtimeLogConfig to get the current real-time log * configuration.

  2. Locally modify the parameters in the real-time * log configuration that you want to update.

  3. Call this API * (UpdateRealtimeLogConfig) by providing the entire real-time log * configuration, including the parameters that you modified and those that you * didn't.

You cannot update a real-time log configuration's * Name or ARN.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRealtimeLogConfig2020_05_31Outcome UpdateRealtimeLogConfig2020_05_31(const Model::UpdateRealtimeLogConfig2020_05_31Request& request) const; /** * A Callable wrapper for UpdateRealtimeLogConfig2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRealtimeLogConfig2020_05_31OutcomeCallable UpdateRealtimeLogConfig2020_05_31Callable(const UpdateRealtimeLogConfig2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateRealtimeLogConfig2020_05_31, request); } /** * An Async wrapper for UpdateRealtimeLogConfig2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRealtimeLogConfig2020_05_31Async(const UpdateRealtimeLogConfig2020_05_31RequestT& request, const UpdateRealtimeLogConfig2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateRealtimeLogConfig2020_05_31, request, handler, context); } /** *

Updates a response headers policy.

When you update a response headers * policy, the entire policy is replaced. You cannot update some policy fields * independent of others. To update a response headers policy configuration:

*

  1. Use GetResponseHeadersPolicyConfig to get the current * policy's configuration.

  2. Modify the fields in the response * headers policy configuration that you want to update.

  3. Call * UpdateResponseHeadersPolicy, providing the entire response headers * policy configuration, including the fields that you modified and those that you * didn't.

See Also:

AWS * API Reference

*/ virtual Model::UpdateResponseHeadersPolicy2020_05_31Outcome UpdateResponseHeadersPolicy2020_05_31(const Model::UpdateResponseHeadersPolicy2020_05_31Request& request) const; /** * A Callable wrapper for UpdateResponseHeadersPolicy2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateResponseHeadersPolicy2020_05_31OutcomeCallable UpdateResponseHeadersPolicy2020_05_31Callable(const UpdateResponseHeadersPolicy2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateResponseHeadersPolicy2020_05_31, request); } /** * An Async wrapper for UpdateResponseHeadersPolicy2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateResponseHeadersPolicy2020_05_31Async(const UpdateResponseHeadersPolicy2020_05_31RequestT& request, const UpdateResponseHeadersPolicy2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateResponseHeadersPolicy2020_05_31, request, handler, context); } /** *

Update a streaming distribution.

See Also:

AWS * API Reference

*/ virtual Model::UpdateStreamingDistribution2020_05_31Outcome UpdateStreamingDistribution2020_05_31(const Model::UpdateStreamingDistribution2020_05_31Request& request) const; /** * A Callable wrapper for UpdateStreamingDistribution2020_05_31 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStreamingDistribution2020_05_31OutcomeCallable UpdateStreamingDistribution2020_05_31Callable(const UpdateStreamingDistribution2020_05_31RequestT& request) const { return SubmitCallable(&CloudFrontClient::UpdateStreamingDistribution2020_05_31, request); } /** * An Async wrapper for UpdateStreamingDistribution2020_05_31 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStreamingDistribution2020_05_31Async(const UpdateStreamingDistribution2020_05_31RequestT& request, const UpdateStreamingDistribution2020_05_31ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CloudFrontClient::UpdateStreamingDistribution2020_05_31, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const CloudFrontClientConfiguration& clientConfiguration); CloudFrontClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace CloudFront } // namespace Aws