@aws-sdk/client-cloudfront 3.32.0 → 3.36.0

package/dist-types/commands/GetFunctionCommand.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 { GetFunctionRequest, GetFunctionResult } from "../models/models_1";
+export interface GetFunctionCommandInput extends GetFunctionRequest {
+}
+export interface GetFunctionCommandOutput extends GetFunctionResult, __MetadataBearer {
+}
+/**
+ * <p>Gets the code of a CloudFront function. To get configuration information and metadata about
+ * 			a function, use <code>DescribeFunction</code>.</p>
+ * 		       <p>To get a function’s code, 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, GetFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetFunctionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetFunctionCommandInput} for command's `input` shape.
+ * @see {@link GetFunctionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetFunctionCommand extends $Command<GetFunctionCommandInput, GetFunctionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetFunctionCommandInput;
+    constructor(input: GetFunctionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionCommandInput, GetFunctionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/GetKeyGroupCommand.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 { GetKeyGroupRequest, GetKeyGroupResult } from "../models/models_1";
+export interface GetKeyGroupCommandInput extends GetKeyGroupRequest {
+}
+export interface GetKeyGroupCommandOutput extends GetKeyGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Gets a key group, including the date and time when the key group was last modified.</p>
+ * 		       <p>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 <code>ListDistributions</code> or <code>GetDistribution</code>. If the key group
+ * 			is not referenced in a cache behavior, you can get the identifier using
+ * 			<code>ListKeyGroups</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetKeyGroupCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetKeyGroupCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetKeyGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetKeyGroupCommandInput} for command's `input` shape.
+ * @see {@link GetKeyGroupCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetKeyGroupCommand extends $Command<GetKeyGroupCommandInput, GetKeyGroupCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetKeyGroupCommandInput;
+    constructor(input: GetKeyGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetKeyGroupCommandInput, GetKeyGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetKeyGroupConfigCommand.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 { GetKeyGroupConfigRequest, GetKeyGroupConfigResult } from "../models/models_1";
+export interface GetKeyGroupConfigCommandInput extends GetKeyGroupConfigRequest {
+}
+export interface GetKeyGroupConfigCommandOutput extends GetKeyGroupConfigResult, __MetadataBearer {
+}
+/**
+ * <p>Gets a key group configuration.</p>
+ * 		       <p>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 <code>ListDistributions</code> or <code>GetDistribution</code>. If the
+ * 			key group is not referenced in a cache behavior, you can get the identifier using
+ * 			<code>ListKeyGroups</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, GetKeyGroupConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetKeyGroupConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetKeyGroupConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetKeyGroupConfigCommandInput} for command's `input` shape.
+ * @see {@link GetKeyGroupConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetKeyGroupConfigCommand extends $Command<GetKeyGroupConfigCommandInput, GetKeyGroupConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetKeyGroupConfigCommandInput;
+    constructor(input: GetKeyGroupConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetKeyGroupConfigCommandInput, GetKeyGroupConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+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 { GetMonitoringSubscriptionRequest, GetMonitoringSubscriptionResult } from "../models/models_1";
+export interface GetMonitoringSubscriptionCommandInput extends GetMonitoringSubscriptionRequest {
+}
+export interface GetMonitoringSubscriptionCommandOutput extends GetMonitoringSubscriptionResult, __MetadataBearer {
+}
+/**
+ * <p>Gets information about whether additional CloudWatch metrics are enabled 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, GetMonitoringSubscriptionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, GetMonitoringSubscriptionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new GetMonitoringSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetMonitoringSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link GetMonitoringSubscriptionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetMonitoringSubscriptionCommand extends $Command<GetMonitoringSubscriptionCommandInput, GetMonitoringSubscriptionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: GetMonitoringSubscriptionCommandInput;
+    constructor(input: GetMonitoringSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMonitoringSubscriptionCommandInput, GetMonitoringSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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

package/dist-types/commands/ListCachePoliciesCommand.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 { ListCachePoliciesRequest, ListCachePoliciesResult } from "../models/models_1";
+export interface ListCachePoliciesCommandInput extends ListCachePoliciesRequest {
+}
+export interface ListCachePoliciesCommandOutput extends ListCachePoliciesResult, __MetadataBearer {
+}
+/**
+ * <p>Gets a list of cache policies.</p>
+ * 		       <p>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 account.</p>
+ * 		       <p>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 <code>NextMarker</code> value from the current
+ * 			response as the <code>Marker</code> value in the subsequent request.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, ListCachePoliciesCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, ListCachePoliciesCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new ListCachePoliciesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCachePoliciesCommandInput} for command's `input` shape.
+ * @see {@link ListCachePoliciesCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListCachePoliciesCommand extends $Command<ListCachePoliciesCommandInput, ListCachePoliciesCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: ListCachePoliciesCommandInput;
+    constructor(input: ListCachePoliciesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCachePoliciesCommandInput, ListCachePoliciesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

@@ -0,0 +1,57 @@
+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 { ListConflictingAliasesRequest, ListConflictingAliasesResult } from "../models/models_1";
+export interface ListConflictingAliasesCommandInput extends ListConflictingAliasesRequest {
+}
+export interface ListConflictingAliasesCommandOutput extends ListConflictingAliasesResult, __MetadataBearer {
+}
+/**
+ * <p>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.</p>
+ * 		       <p>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 <code>www.example.com</code> as
+ * 			input, the returned list can include <code>www.example.com</code> and the overlapping
+ * 			wildcard alternate domain name (<code>*.example.com</code>), if they exist. If you
+ * 			provide <code>*.example.com</code> as input, the returned list can include
+ * 			<code>*.example.com</code> and any alternate domain names covered by that wildcard (for
+ * 			example, <code>www.example.com</code>, <code>test.example.com</code>,
+ * 			<code>dev.example.com</code>, and so on), if they exist.</p>
+ * 		       <p>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
+ * 			<a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/CNAMEs.html#alternate-domain-names-move">Moving an alternate domain name to a different distribution</a>
+ * 			in the <i>Amazon CloudFront Developer Guide</i>.</p>
+ * 		       <p>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 <code>NextMarker</code> value from the current
+ * 			response as the <code>Marker</code> value in the subsequent request.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, ListConflictingAliasesCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, ListConflictingAliasesCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new ListConflictingAliasesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListConflictingAliasesCommandInput} for command's `input` shape.
+ * @see {@link ListConflictingAliasesCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListConflictingAliasesCommand extends $Command<ListConflictingAliasesCommandInput, ListConflictingAliasesCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: ListConflictingAliasesCommandInput;
+    constructor(input: ListConflictingAliasesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConflictingAliasesCommandInput, ListConflictingAliasesCommandOutput>;
+    private serialize;
+    private deserialize;
+}