@aws-sdk/client-cloudfront 3.32.0 → 3.36.0

package/dist-types/commands/CreateKeyGroupCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { CreateKeyGroupRequest, CreateKeyGroupResult } from "../models/models_0";
+export interface CreateKeyGroupCommandInput extends CreateKeyGroupRequest {
+}
+export interface CreateKeyGroupCommandOutput extends CreateKeyGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a key group that you can use with <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html">CloudFront signed URLs and signed cookies</a>.</p>
+ * 		       <p>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 <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html">Serving private content</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateKeyGroupCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateKeyGroupCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateKeyGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateKeyGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateKeyGroupCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateKeyGroupCommand extends $Command<CreateKeyGroupCommandInput, CreateKeyGroupCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: CreateKeyGroupCommandInput;
+    constructor(input: CreateKeyGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateKeyGroupCommandInput, CreateKeyGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateMonitoringSubscriptionCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { CreateMonitoringSubscriptionRequest, CreateMonitoringSubscriptionResult } from "../models/models_0";
+export interface CreateMonitoringSubscriptionCommandInput extends CreateMonitoringSubscriptionRequest {
+}
+export interface CreateMonitoringSubscriptionCommandOutput extends CreateMonitoringSubscriptionResult, __MetadataBearer {
+}
+/**
+ * <p>Enables additional CloudWatch metrics for the specified CloudFront distribution. The
+ * 			additional metrics incur an additional cost.</p>
+ * 		       <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional">Viewing additional CloudFront distribution metrics</a> in the
+ * 			<i>Amazon CloudFront Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateMonitoringSubscriptionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateMonitoringSubscriptionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateMonitoringSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateMonitoringSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link CreateMonitoringSubscriptionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateMonitoringSubscriptionCommand extends $Command<CreateMonitoringSubscriptionCommandInput, CreateMonitoringSubscriptionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: CreateMonitoringSubscriptionCommandInput;
+    constructor(input: CreateMonitoringSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMonitoringSubscriptionCommandInput, CreateMonitoringSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateOriginRequestPolicyCommand.d.ts

@@ -0,0 +1,59 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { CreateOriginRequestPolicyRequest, CreateOriginRequestPolicyResult } from "../models/models_0";
+export interface CreateOriginRequestPolicyCommandInput extends CreateOriginRequestPolicyRequest {
+}
+export interface CreateOriginRequestPolicyCommandOutput extends CreateOriginRequestPolicyResult, __MetadataBearer {
+}
+/**
+ * <p>Creates an origin request policy.</p>
+ * 		       <p>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:</p>
+ * 		       <ul>
+ *             <li>
+ * 				           <p>The request body and the URL path (without the domain name) from the viewer
+ * 					request.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>The headers that CloudFront automatically includes in every origin request, including
+ * 					<code>Host</code>, <code>User-Agent</code>, and <code>X-Amz-Cf-Id</code>.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>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.</p>
+ * 			         </li>
+ *          </ul>
+ * 		       <p>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 <code>CachePolicy</code>.</p>
+ * 		       <p>For more information about origin request policies, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/controlling-origin-requests.html">Controlling origin requests</a> in the
+ * 			<i>Amazon CloudFront Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateOriginRequestPolicyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateOriginRequestPolicyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateOriginRequestPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateOriginRequestPolicyCommandInput} for command's `input` shape.
+ * @see {@link CreateOriginRequestPolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateOriginRequestPolicyCommand extends $Command<CreateOriginRequestPolicyCommandInput, CreateOriginRequestPolicyCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: CreateOriginRequestPolicyCommandInput;
+    constructor(input: CreateOriginRequestPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateOriginRequestPolicyCommandInput, CreateOriginRequestPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreatePublicKeyCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { CreatePublicKeyRequest, CreatePublicKeyResult } from "../models/models_0";
+export interface CreatePublicKeyCommandInput extends CreatePublicKeyRequest {
+}
+export interface CreatePublicKeyCommandOutput extends CreatePublicKeyResult, __MetadataBearer {
+}
+/**
+ * <p>Uploads a public key to CloudFront that you can use with <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html">signed URLs and signed cookies</a>, or with <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/field-level-encryption.html">field-level encryption</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreatePublicKeyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreatePublicKeyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreatePublicKeyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreatePublicKeyCommandInput} for command's `input` shape.
+ * @see {@link CreatePublicKeyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreatePublicKeyCommand extends $Command<CreatePublicKeyCommandInput, CreatePublicKeyCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: CreatePublicKeyCommandInput;
+    constructor(input: CreatePublicKeyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePublicKeyCommandInput, CreatePublicKeyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateRealtimeLogConfigCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { CreateRealtimeLogConfigRequest, CreateRealtimeLogConfigResult } from "../models/models_0";
+export interface CreateRealtimeLogConfigCommandInput extends CreateRealtimeLogConfigRequest {
+}
+export interface CreateRealtimeLogConfigCommandOutput extends CreateRealtimeLogConfigResult, __MetadataBearer {
+}
+/**
+ * <p>Creates a real-time log configuration.</p>
+ * 		       <p>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.</p>
+ * 		       <p>For more information about real-time log configurations, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html">Real-time logs</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateRealtimeLogConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateRealtimeLogConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateRealtimeLogConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateRealtimeLogConfigCommandInput} for command's `input` shape.
+ * @see {@link CreateRealtimeLogConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateRealtimeLogConfigCommand extends $Command<CreateRealtimeLogConfigCommandInput, CreateRealtimeLogConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: CreateRealtimeLogConfigCommandInput;
+    constructor(input: CreateRealtimeLogConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRealtimeLogConfigCommandInput, CreateRealtimeLogConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateStreamingDistributionCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { CreateStreamingDistributionRequest, CreateStreamingDistributionResult } from "../models/models_0";
+export interface CreateStreamingDistributionCommandInput extends CreateStreamingDistributionRequest {
+}
+export interface CreateStreamingDistributionCommandOutput extends CreateStreamingDistributionResult, __MetadataBearer {
+}
+/**
+ * <p>This API is deprecated.
+ *             Amazon CloudFront is deprecating real-time messaging protocol (RTMP) distributions on December 31, 2020.
+ *             For more information, <a href="http://forums.aws.amazon.com/ann.jspa?annID=7356">read the announcement</a> on the Amazon CloudFront discussion forum.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateStreamingDistributionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateStreamingDistributionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateStreamingDistributionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateStreamingDistributionCommandInput} for command's `input` shape.
+ * @see {@link CreateStreamingDistributionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateStreamingDistributionCommand extends $Command<CreateStreamingDistributionCommandInput, CreateStreamingDistributionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: CreateStreamingDistributionCommandInput;
+    constructor(input: CreateStreamingDistributionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStreamingDistributionCommandInput, CreateStreamingDistributionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateStreamingDistributionWithTagsCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { CreateStreamingDistributionWithTagsRequest, CreateStreamingDistributionWithTagsResult } from "../models/models_0";
+export interface CreateStreamingDistributionWithTagsCommandInput extends CreateStreamingDistributionWithTagsRequest {
+}
+export interface CreateStreamingDistributionWithTagsCommandOutput extends CreateStreamingDistributionWithTagsResult, __MetadataBearer {
+}
+/**
+ * <p>This API is deprecated.
+ *             Amazon CloudFront is deprecating real-time messaging protocol (RTMP) distributions on December 31, 2020.
+ *             For more information, <a href="http://forums.aws.amazon.com/ann.jspa?annID=7356">read the announcement</a> on the Amazon CloudFront discussion forum.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateStreamingDistributionWithTagsCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateStreamingDistributionWithTagsCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateStreamingDistributionWithTagsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateStreamingDistributionWithTagsCommandInput} for command's `input` shape.
+ * @see {@link CreateStreamingDistributionWithTagsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateStreamingDistributionWithTagsCommand extends $Command<CreateStreamingDistributionWithTagsCommandInput, CreateStreamingDistributionWithTagsCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: CreateStreamingDistributionWithTagsCommandInput;
+    constructor(input: CreateStreamingDistributionWithTagsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateStreamingDistributionWithTagsCommandInput, CreateStreamingDistributionWithTagsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteCachePolicyCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { DeleteCachePolicyRequest } from "../models/models_0";
+export interface DeleteCachePolicyCommandInput extends DeleteCachePolicyRequest {
+}
+export interface DeleteCachePolicyCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes a cache policy.</p>
+ * 		       <p>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.</p>
+ * 		       <p>To delete a cache policy, you must provide the policy’s identifier and version. To get these
+ * 			values, you can use <code>ListCachePolicies</code> or
+ * 			<code>GetCachePolicy</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteCachePolicyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteCachePolicyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteCachePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteCachePolicyCommandInput} for command's `input` shape.
+ * @see {@link DeleteCachePolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteCachePolicyCommand extends $Command<DeleteCachePolicyCommandInput, DeleteCachePolicyCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteCachePolicyCommandInput;
+    constructor(input: DeleteCachePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCachePolicyCommandInput, DeleteCachePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteCloudFrontOriginAccessIdentityCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { DeleteCloudFrontOriginAccessIdentityRequest } from "../models/models_0";
+export interface DeleteCloudFrontOriginAccessIdentityCommandInput extends DeleteCloudFrontOriginAccessIdentityRequest {
+}
+export interface DeleteCloudFrontOriginAccessIdentityCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Delete an origin access identity. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteCloudFrontOriginAccessIdentityCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteCloudFrontOriginAccessIdentityCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteCloudFrontOriginAccessIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteCloudFrontOriginAccessIdentityCommandInput} for command's `input` shape.
+ * @see {@link DeleteCloudFrontOriginAccessIdentityCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteCloudFrontOriginAccessIdentityCommand extends $Command<DeleteCloudFrontOriginAccessIdentityCommandInput, DeleteCloudFrontOriginAccessIdentityCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteCloudFrontOriginAccessIdentityCommandInput;
+    constructor(input: DeleteCloudFrontOriginAccessIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCloudFrontOriginAccessIdentityCommandInput, DeleteCloudFrontOriginAccessIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteDistributionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { DeleteDistributionRequest } from "../models/models_0";
+export interface DeleteDistributionCommandInput extends DeleteDistributionRequest {
+}
+export interface DeleteDistributionCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Delete a distribution. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteDistributionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteDistributionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteDistributionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDistributionCommandInput} for command's `input` shape.
+ * @see {@link DeleteDistributionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteDistributionCommand extends $Command<DeleteDistributionCommandInput, DeleteDistributionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteDistributionCommandInput;
+    constructor(input: DeleteDistributionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDistributionCommandInput, DeleteDistributionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteFieldLevelEncryptionConfigCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { DeleteFieldLevelEncryptionConfigRequest } from "../models/models_0";
+export interface DeleteFieldLevelEncryptionConfigCommandInput extends DeleteFieldLevelEncryptionConfigRequest {
+}
+export interface DeleteFieldLevelEncryptionConfigCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Remove a field-level encryption configuration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteFieldLevelEncryptionConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteFieldLevelEncryptionConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteFieldLevelEncryptionConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteFieldLevelEncryptionConfigCommandInput} for command's `input` shape.
+ * @see {@link DeleteFieldLevelEncryptionConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteFieldLevelEncryptionConfigCommand extends $Command<DeleteFieldLevelEncryptionConfigCommandInput, DeleteFieldLevelEncryptionConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteFieldLevelEncryptionConfigCommandInput;
+    constructor(input: DeleteFieldLevelEncryptionConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFieldLevelEncryptionConfigCommandInput, DeleteFieldLevelEncryptionConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteFieldLevelEncryptionProfileCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { DeleteFieldLevelEncryptionProfileRequest } from "../models/models_0";
+export interface DeleteFieldLevelEncryptionProfileCommandInput extends DeleteFieldLevelEncryptionProfileRequest {
+}
+export interface DeleteFieldLevelEncryptionProfileCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Remove a field-level encryption profile.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteFieldLevelEncryptionProfileCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteFieldLevelEncryptionProfileCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteFieldLevelEncryptionProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteFieldLevelEncryptionProfileCommandInput} for command's `input` shape.
+ * @see {@link DeleteFieldLevelEncryptionProfileCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteFieldLevelEncryptionProfileCommand extends $Command<DeleteFieldLevelEncryptionProfileCommandInput, DeleteFieldLevelEncryptionProfileCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteFieldLevelEncryptionProfileCommandInput;
+    constructor(input: DeleteFieldLevelEncryptionProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFieldLevelEncryptionProfileCommandInput, DeleteFieldLevelEncryptionProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteFunctionCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { DeleteFunctionRequest } from "../models/models_0";
+export interface DeleteFunctionCommandInput extends DeleteFunctionRequest {
+}
+export interface DeleteFunctionCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes a CloudFront function.</p>
+ * 		       <p>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.</p>
+ * 		       <p>To delete a function, you must provide the function’s name and version
+ * 			(<code>ETag</code> value). To get these values, you can use <code>ListFunctions</code>
+ * 			and <code>DescribeFunction</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteFunctionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteFunctionCommandInput} for command's `input` shape.
+ * @see {@link DeleteFunctionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteFunctionCommand extends $Command<DeleteFunctionCommandInput, DeleteFunctionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteFunctionCommandInput;
+    constructor(input: DeleteFunctionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionCommandInput, DeleteFunctionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteKeyGroupCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { DeleteKeyGroupRequest } from "../models/models_0";
+export interface DeleteKeyGroupCommandInput extends DeleteKeyGroupRequest {
+}
+export interface DeleteKeyGroupCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes a key group.</p>
+ * 		       <p>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.</p>
+ * 		       <p>To delete a key group, you must provide the key group’s identifier and version. To get
+ * 			these values, use <code>ListKeyGroups</code> followed by <code>GetKeyGroup</code> or
+ * 			<code>GetKeyGroupConfig</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteKeyGroupCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteKeyGroupCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteKeyGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteKeyGroupCommandInput} for command's `input` shape.
+ * @see {@link DeleteKeyGroupCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteKeyGroupCommand extends $Command<DeleteKeyGroupCommandInput, DeleteKeyGroupCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteKeyGroupCommandInput;
+    constructor(input: DeleteKeyGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteKeyGroupCommandInput, DeleteKeyGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteMonitoringSubscriptionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { DeleteMonitoringSubscriptionRequest, DeleteMonitoringSubscriptionResult } from "../models/models_0";
+export interface DeleteMonitoringSubscriptionCommandInput extends DeleteMonitoringSubscriptionRequest {
+}
+export interface DeleteMonitoringSubscriptionCommandOutput extends DeleteMonitoringSubscriptionResult, __MetadataBearer {
+}
+/**
+ * <p>Disables additional CloudWatch metrics for the specified CloudFront distribution.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteMonitoringSubscriptionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteMonitoringSubscriptionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteMonitoringSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteMonitoringSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link DeleteMonitoringSubscriptionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteMonitoringSubscriptionCommand extends $Command<DeleteMonitoringSubscriptionCommandInput, DeleteMonitoringSubscriptionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteMonitoringSubscriptionCommandInput;
+    constructor(input: DeleteMonitoringSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMonitoringSubscriptionCommandInput, DeleteMonitoringSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}