@aws-sdk/client-cloudfront 3.36.0 → 3.39.0

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

@@ -6,33 +6,11 @@ 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/ts3.4/commands/GetCachePolicyCommand.d.ts

@@ -6,42 +6,11 @@ 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/ts3.4/commands/GetCachePolicyConfigCommand.d.ts

@@ -6,34 +6,11 @@ export interface GetCachePolicyConfigCommandInput extends GetCachePolicyConfigRe
 }
 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/ts3.4/commands/GetCloudFrontOriginAccessIdentityCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetCloudFrontOriginAccessIdentityCommandInput extends GetCloudF
 }
 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/ts3.4/commands/GetCloudFrontOriginAccessIdentityConfigCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetCloudFrontOriginAccessIdentityConfigCommandInput extends Get
 }
 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/ts3.4/commands/GetDistributionCommand.d.ts

@@ -6,29 +6,11 @@ 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/ts3.4/commands/GetDistributionConfigCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetDistributionConfigCommandInput extends GetDistributionConfig
 }
 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/ts3.4/commands/GetFieldLevelEncryptionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetFieldLevelEncryptionCommandInput extends GetFieldLevelEncryp
 }
 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/ts3.4/commands/GetFieldLevelEncryptionConfigCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetFieldLevelEncryptionConfigCommandInput extends GetFieldLevel
 }
 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/ts3.4/commands/GetFieldLevelEncryptionProfileCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetFieldLevelEncryptionProfileCommandInput extends GetFieldLeve
 }
 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/ts3.4/commands/GetFieldLevelEncryptionProfileConfigCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetFieldLevelEncryptionProfileConfigCommandInput extends GetFie
 }
 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;

package/dist-types/ts3.4/commands/GetFunctionCommand.d.ts

@@ -6,32 +6,11 @@ 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/ts3.4/commands/GetInvalidationCommand.d.ts

@@ -6,29 +6,11 @@ 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/ts3.4/commands/GetKeyGroupCommand.d.ts

@@ -6,34 +6,11 @@ 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/ts3.4/commands/GetKeyGroupConfigCommand.d.ts

@@ -6,34 +6,11 @@ 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/ts3.4/commands/GetMonitoringSubscriptionCommand.d.ts

@@ -6,30 +6,11 @@ export interface GetMonitoringSubscriptionCommandInput extends GetMonitoringSubs
 }
 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/ts3.4/commands/GetOriginRequestPolicyCommand.d.ts

@@ -6,42 +6,11 @@ export interface GetOriginRequestPolicyCommandInput extends GetOriginRequestPoli
 }
 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/ts3.4/commands/GetOriginRequestPolicyConfigCommand.d.ts

@@ -6,35 +6,11 @@ export interface GetOriginRequestPolicyConfigCommandInput extends GetOriginReque
 }
 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;