@aws-sdk/client-cloudfront 3.32.0 → 3.36.0

package/dist-types/commands/DeleteOriginRequestPolicyCommand.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 { DeleteOriginRequestPolicyRequest } from "../models/models_0";
+export interface DeleteOriginRequestPolicyCommandInput extends DeleteOriginRequestPolicyRequest {
+}
+export interface DeleteOriginRequestPolicyCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes an origin request policy.</p>
+ * 		       <p>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.</p>
+ * 		       <p>To delete an origin request policy, you must provide the policy’s identifier and version. To
+ * 			get the identifier, you can use <code>ListOriginRequestPolicies</code> or
+ * 			<code>GetOriginRequestPolicy</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteOriginRequestPolicyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteOriginRequestPolicyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteOriginRequestPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteOriginRequestPolicyCommandInput} for command's `input` shape.
+ * @see {@link DeleteOriginRequestPolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteOriginRequestPolicyCommand extends $Command<DeleteOriginRequestPolicyCommandInput, DeleteOriginRequestPolicyCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteOriginRequestPolicyCommandInput;
+    constructor(input: DeleteOriginRequestPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteOriginRequestPolicyCommandInput, DeleteOriginRequestPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeletePublicKeyCommand.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 { DeletePublicKeyRequest } from "../models/models_0";
+export interface DeletePublicKeyCommandInput extends DeletePublicKeyRequest {
+}
+export interface DeletePublicKeyCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Remove a public key you previously added to CloudFront.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeletePublicKeyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeletePublicKeyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeletePublicKeyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeletePublicKeyCommandInput} for command's `input` shape.
+ * @see {@link DeletePublicKeyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeletePublicKeyCommand extends $Command<DeletePublicKeyCommandInput, DeletePublicKeyCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeletePublicKeyCommandInput;
+    constructor(input: DeletePublicKeyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePublicKeyCommandInput, DeletePublicKeyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteRealtimeLogConfigCommand.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 { DeleteRealtimeLogConfigRequest } from "../models/models_0";
+export interface DeleteRealtimeLogConfigCommandInput extends DeleteRealtimeLogConfigRequest {
+}
+export interface DeleteRealtimeLogConfigCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes a real-time log configuration.</p>
+ * 		       <p>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.</p>
+ * 		       <p>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.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DeleteRealtimeLogConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteRealtimeLogConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteRealtimeLogConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteRealtimeLogConfigCommandInput} for command's `input` shape.
+ * @see {@link DeleteRealtimeLogConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteRealtimeLogConfigCommand extends $Command<DeleteRealtimeLogConfigCommandInput, DeleteRealtimeLogConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteRealtimeLogConfigCommandInput;
+    constructor(input: DeleteRealtimeLogConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteRealtimeLogConfigCommandInput, DeleteRealtimeLogConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,82 @@
+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 { DeleteStreamingDistributionRequest } from "../models/models_0";
+export interface DeleteStreamingDistributionCommandInput extends DeleteStreamingDistributionRequest {
+}
+export interface DeleteStreamingDistributionCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Delete a streaming distribution. To delete an RTMP distribution using the CloudFront API,
+ * 			perform the following steps.</p>
+ *
+ * 		       <p>
+ *             <b>To delete an RTMP distribution using the CloudFront
+ * 			API</b>:</p>
+ * 		       <ol>
+ *             <li>
+ * 				           <p>Disable the RTMP distribution.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Submit a <code>GET Streaming Distribution Config</code> request to get the current
+ * 					configuration and the <code>Etag</code> header for the distribution. </p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Update the XML document that was returned in the response to your <code>GET
+ * 						Streaming Distribution Config</code> request to change the value of <code>Enabled</code>
+ * 					to <code>false</code>.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Submit a <code>PUT Streaming Distribution Config</code> 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 <code>If-Match</code> header to the
+ * 					value of the <code>ETag</code> header that CloudFront returned when you submitted the <code>GET
+ * 						Streaming Distribution Config</code> request in Step 2.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Review the response to the <code>PUT Streaming Distribution Config</code> request
+ * 					to confirm that the distribution was successfully disabled.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Submit a <code>GET Streaming Distribution Config</code> request to confirm that
+ * 					your changes have propagated. When propagation is complete, the value of
+ * 						<code>Status</code> is <code>Deployed</code>.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Submit a <code>DELETE Streaming Distribution</code> request. Set the value of the
+ * 					HTTP <code>If-Match</code> header to the value of the <code>ETag</code> header that CloudFront
+ * 					returned when you submitted the <code>GET Streaming Distribution Config</code> request in
+ * 					Step 2.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Review the response to your <code>DELETE Streaming Distribution</code> request to
+ * 					confirm that the distribution was successfully deleted.</p>
+ * 			         </li>
+ *          </ol>
+ * 		       <p>For information about deleting a distribution using the CloudFront console, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/HowToDeleteDistribution.html">Deleting a Distribution</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, DeleteStreamingDistributionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DeleteStreamingDistributionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DeleteStreamingDistributionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteStreamingDistributionCommandInput} for command's `input` shape.
+ * @see {@link DeleteStreamingDistributionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DeleteStreamingDistributionCommand extends $Command<DeleteStreamingDistributionCommandInput, DeleteStreamingDistributionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DeleteStreamingDistributionCommandInput;
+    constructor(input: DeleteStreamingDistributionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteStreamingDistributionCommandInput, DeleteStreamingDistributionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,39 @@
+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 { DescribeFunctionRequest, DescribeFunctionResult } from "../models/models_0";
+export interface DescribeFunctionCommandInput extends DescribeFunctionRequest {
+}
+export interface DescribeFunctionCommandOutput extends DescribeFunctionResult, __MetadataBearer {
+}
+/**
+ * <p>Gets configuration information and metadata about a CloudFront function, but not the function’s
+ * 			code. To get a function’s code, use <code>GetFunction</code>.</p>
+ * 		       <p>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
+ * 			<code>ListFunctions</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, DescribeFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, DescribeFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new DescribeFunctionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeFunctionCommandInput} for command's `input` shape.
+ * @see {@link DescribeFunctionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribeFunctionCommand extends $Command<DescribeFunctionCommandInput, DescribeFunctionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: DescribeFunctionCommandInput;
+    constructor(input: DescribeFunctionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFunctionCommandInput, DescribeFunctionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,48 @@
+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 { GetCachePolicyRequest, GetCachePolicyResult } from "../models/models_0";
+export interface GetCachePolicyCommandInput extends GetCachePolicyRequest {
+}
+export interface GetCachePolicyCommandOutput extends GetCachePolicyResult, __MetadataBearer {
+}
+/**
+ * <p>Gets a cache policy, including the following metadata:</p>
+ * 		       <ul>
+ *             <li>
+ * 				           <p>The policy’s identifier.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>The date and time when the policy was last modified.</p>
+ * 			         </li>
+ *          </ul>
+ * 		       <p>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
+ * 			<code>ListDistributions</code> or <code>GetDistribution</code>. If the cache policy is
+ * 			not attached to a cache behavior, you can get the identifier using
+ * 			<code>ListCachePolicies</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetCachePolicyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetCachePolicyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetCachePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCachePolicyCommandInput} for command's `input` shape.
+ * @see {@link GetCachePolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCachePolicyCommand extends $Command<GetCachePolicyCommandInput, GetCachePolicyCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetCachePolicyCommandInput;
+    constructor(input: GetCachePolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCachePolicyCommandInput, GetCachePolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+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 { GetCachePolicyConfigRequest, GetCachePolicyConfigResult } from "../models/models_0";
+export interface GetCachePolicyConfigCommandInput extends GetCachePolicyConfigRequest {
+}
+export interface GetCachePolicyConfigCommandOutput extends GetCachePolicyConfigResult, __MetadataBearer {
+}
+/**
+ * <p>Gets a cache policy configuration.</p>
+ * 		       <p>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 <code>ListDistributions</code> or <code>GetDistribution</code>. If the
+ * 			cache policy is not attached to a cache behavior, you can get the identifier using
+ * 			<code>ListCachePolicies</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetCachePolicyConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetCachePolicyConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetCachePolicyConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCachePolicyConfigCommandInput} for command's `input` shape.
+ * @see {@link GetCachePolicyConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCachePolicyConfigCommand extends $Command<GetCachePolicyConfigCommandInput, GetCachePolicyConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetCachePolicyConfigCommandInput;
+    constructor(input: GetCachePolicyConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCachePolicyConfigCommandInput, GetCachePolicyConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCloudFrontOriginAccessIdentityCommand.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 { GetCloudFrontOriginAccessIdentityRequest, GetCloudFrontOriginAccessIdentityResult } from "../models/models_0";
+export interface GetCloudFrontOriginAccessIdentityCommandInput extends GetCloudFrontOriginAccessIdentityRequest {
+}
+export interface GetCloudFrontOriginAccessIdentityCommandOutput extends GetCloudFrontOriginAccessIdentityResult, __MetadataBearer {
+}
+/**
+ * <p>Get the information about an origin access identity. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetCloudFrontOriginAccessIdentityCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetCloudFrontOriginAccessIdentityCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetCloudFrontOriginAccessIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCloudFrontOriginAccessIdentityCommandInput} for command's `input` shape.
+ * @see {@link GetCloudFrontOriginAccessIdentityCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCloudFrontOriginAccessIdentityCommand extends $Command<GetCloudFrontOriginAccessIdentityCommandInput, GetCloudFrontOriginAccessIdentityCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetCloudFrontOriginAccessIdentityCommandInput;
+    constructor(input: GetCloudFrontOriginAccessIdentityCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCloudFrontOriginAccessIdentityCommandInput, GetCloudFrontOriginAccessIdentityCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCloudFrontOriginAccessIdentityConfigCommand.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 { GetCloudFrontOriginAccessIdentityConfigRequest, GetCloudFrontOriginAccessIdentityConfigResult } from "../models/models_0";
+export interface GetCloudFrontOriginAccessIdentityConfigCommandInput extends GetCloudFrontOriginAccessIdentityConfigRequest {
+}
+export interface GetCloudFrontOriginAccessIdentityConfigCommandOutput extends GetCloudFrontOriginAccessIdentityConfigResult, __MetadataBearer {
+}
+/**
+ * <p>Get the configuration information about an origin access identity. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetCloudFrontOriginAccessIdentityConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetCloudFrontOriginAccessIdentityConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetCloudFrontOriginAccessIdentityConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCloudFrontOriginAccessIdentityConfigCommandInput} for command's `input` shape.
+ * @see {@link GetCloudFrontOriginAccessIdentityConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCloudFrontOriginAccessIdentityConfigCommand extends $Command<GetCloudFrontOriginAccessIdentityConfigCommandInput, GetCloudFrontOriginAccessIdentityConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetCloudFrontOriginAccessIdentityConfigCommandInput;
+    constructor(input: GetCloudFrontOriginAccessIdentityConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCloudFrontOriginAccessIdentityConfigCommandInput, GetCloudFrontOriginAccessIdentityConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDistributionCommand.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 { GetDistributionRequest, GetDistributionResult } from "../models/models_0";
+export interface GetDistributionCommandInput extends GetDistributionRequest {
+}
+export interface GetDistributionCommandOutput extends GetDistributionResult, __MetadataBearer {
+}
+/**
+ * <p>Get the information about a distribution.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetDistributionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetDistributionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetDistributionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDistributionCommandInput} for command's `input` shape.
+ * @see {@link GetDistributionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDistributionCommand extends $Command<GetDistributionCommandInput, GetDistributionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetDistributionCommandInput;
+    constructor(input: GetDistributionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDistributionCommandInput, GetDistributionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDistributionConfigCommand.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 { GetDistributionConfigRequest, GetDistributionConfigResult } from "../models/models_0";
+export interface GetDistributionConfigCommandInput extends GetDistributionConfigRequest {
+}
+export interface GetDistributionConfigCommandOutput extends GetDistributionConfigResult, __MetadataBearer {
+}
+/**
+ * <p>Get the configuration information about a distribution. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetDistributionConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetDistributionConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetDistributionConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDistributionConfigCommandInput} for command's `input` shape.
+ * @see {@link GetDistributionConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDistributionConfigCommand extends $Command<GetDistributionConfigCommandInput, GetDistributionConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetDistributionConfigCommandInput;
+    constructor(input: GetDistributionConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDistributionConfigCommandInput, GetDistributionConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetFieldLevelEncryptionCommand.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 { GetFieldLevelEncryptionRequest, GetFieldLevelEncryptionResult } from "../models/models_0";
+export interface GetFieldLevelEncryptionCommandInput extends GetFieldLevelEncryptionRequest {
+}
+export interface GetFieldLevelEncryptionCommandOutput extends GetFieldLevelEncryptionResult, __MetadataBearer {
+}
+/**
+ * <p>Get the field-level encryption configuration information.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetFieldLevelEncryptionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetFieldLevelEncryptionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetFieldLevelEncryptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetFieldLevelEncryptionCommandInput} for command's `input` shape.
+ * @see {@link GetFieldLevelEncryptionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetFieldLevelEncryptionCommand extends $Command<GetFieldLevelEncryptionCommandInput, GetFieldLevelEncryptionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetFieldLevelEncryptionCommandInput;
+    constructor(input: GetFieldLevelEncryptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFieldLevelEncryptionCommandInput, GetFieldLevelEncryptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetFieldLevelEncryptionConfigCommand.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 { GetFieldLevelEncryptionConfigRequest, GetFieldLevelEncryptionConfigResult } from "../models/models_1";
+export interface GetFieldLevelEncryptionConfigCommandInput extends GetFieldLevelEncryptionConfigRequest {
+}
+export interface GetFieldLevelEncryptionConfigCommandOutput extends GetFieldLevelEncryptionConfigResult, __MetadataBearer {
+}
+/**
+ * <p>Get the field-level encryption configuration information.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetFieldLevelEncryptionConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetFieldLevelEncryptionConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetFieldLevelEncryptionConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetFieldLevelEncryptionConfigCommandInput} for command's `input` shape.
+ * @see {@link GetFieldLevelEncryptionConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetFieldLevelEncryptionConfigCommand extends $Command<GetFieldLevelEncryptionConfigCommandInput, GetFieldLevelEncryptionConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetFieldLevelEncryptionConfigCommandInput;
+    constructor(input: GetFieldLevelEncryptionConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFieldLevelEncryptionConfigCommandInput, GetFieldLevelEncryptionConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetFieldLevelEncryptionProfileCommand.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 { GetFieldLevelEncryptionProfileRequest, GetFieldLevelEncryptionProfileResult } from "../models/models_1";
+export interface GetFieldLevelEncryptionProfileCommandInput extends GetFieldLevelEncryptionProfileRequest {
+}
+export interface GetFieldLevelEncryptionProfileCommandOutput extends GetFieldLevelEncryptionProfileResult, __MetadataBearer {
+}
+/**
+ * <p>Get the field-level encryption profile information.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetFieldLevelEncryptionProfileCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetFieldLevelEncryptionProfileCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetFieldLevelEncryptionProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetFieldLevelEncryptionProfileCommandInput} for command's `input` shape.
+ * @see {@link GetFieldLevelEncryptionProfileCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetFieldLevelEncryptionProfileCommand extends $Command<GetFieldLevelEncryptionProfileCommandInput, GetFieldLevelEncryptionProfileCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetFieldLevelEncryptionProfileCommandInput;
+    constructor(input: GetFieldLevelEncryptionProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFieldLevelEncryptionProfileCommandInput, GetFieldLevelEncryptionProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetFieldLevelEncryptionProfileConfigCommand.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 { GetFieldLevelEncryptionProfileConfigRequest, GetFieldLevelEncryptionProfileConfigResult } from "../models/models_1";
+export interface GetFieldLevelEncryptionProfileConfigCommandInput extends GetFieldLevelEncryptionProfileConfigRequest {
+}
+export interface GetFieldLevelEncryptionProfileConfigCommandOutput extends GetFieldLevelEncryptionProfileConfigResult, __MetadataBearer {
+}
+/**
+ * <p>Get the field-level encryption profile configuration information.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetFieldLevelEncryptionProfileConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetFieldLevelEncryptionProfileConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetFieldLevelEncryptionProfileConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetFieldLevelEncryptionProfileConfigCommandInput} for command's `input` shape.
+ * @see {@link GetFieldLevelEncryptionProfileConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetFieldLevelEncryptionProfileConfigCommand extends $Command<GetFieldLevelEncryptionProfileConfigCommandInput, GetFieldLevelEncryptionProfileConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetFieldLevelEncryptionProfileConfigCommandInput;
+    constructor(input: GetFieldLevelEncryptionProfileConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFieldLevelEncryptionProfileConfigCommandInput, GetFieldLevelEncryptionProfileConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}