@aws-sdk/client-cloudfront 3.36.0 → 3.39.0

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

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

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

@@ -6,32 +6,11 @@ export interface CreateRealtimeLogConfigCommandInput extends CreateRealtimeLogCo
 }
 export interface CreateRealtimeLogConfigCommandOutput extends CreateRealtimeLogConfigResult, __MetadataBearer {
 }
-/**
- * <p>Creates a real-time log configuration.</p>
- * 		       <p>After you create a real-time log configuration, you can attach it to one or more cache
- * 			behaviors to send real-time log data to the specified Amazon Kinesis data stream.</p>
- * 		       <p>For more information about real-time log configurations, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html">Real-time logs</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, CreateRealtimeLogConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, CreateRealtimeLogConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new CreateRealtimeLogConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRealtimeLogConfigCommandInput} for command's `input` shape.
- * @see {@link CreateRealtimeLogConfigCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateRealtimeLogConfigCommand extends $Command<CreateRealtimeLogConfigCommandInput, CreateRealtimeLogConfigCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: CreateRealtimeLogConfigCommandInput;
     constructor(input: CreateRealtimeLogConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRealtimeLogConfigCommandInput, CreateRealtimeLogConfigCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface DeleteCachePolicyCommandInput extends DeleteCachePolicyRequest
 }
 export interface DeleteCachePolicyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a cache policy.</p>
- * 		       <p>You cannot delete a cache policy if it’s attached to a cache behavior. First update your
- * 			distributions to remove the cache policy from all cache behaviors, then delete the cache
- * 			policy.</p>
- * 		       <p>To delete a cache policy, you must provide the policy’s identifier and version. To get these
- * 			values, you can use <code>ListCachePolicies</code> or
- * 			<code>GetCachePolicy</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, DeleteCachePolicyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, DeleteCachePolicyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new DeleteCachePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteCachePolicyCommandInput} for command's `input` shape.
- * @see {@link DeleteCachePolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteCachePolicyCommand extends $Command<DeleteCachePolicyCommandInput, DeleteCachePolicyCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: DeleteCachePolicyCommandInput;
     constructor(input: DeleteCachePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCachePolicyCommandInput, DeleteCachePolicyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,35 +6,11 @@ export interface DeleteFunctionCommandInput extends DeleteFunctionRequest {
 }
 export interface DeleteFunctionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a CloudFront function.</p>
- * 		       <p>You cannot delete a function if it’s associated with a cache behavior. First, update your
- * 			distributions to remove the function association from all cache behaviors, then delete
- * 			the function.</p>
- * 		       <p>To delete a function, you must provide the function’s name and version
- * 			(<code>ETag</code> value). To get these values, you can use <code>ListFunctions</code>
- * 			and <code>DescribeFunction</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, DeleteFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, DeleteFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new DeleteFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteFunctionCommandInput} for command's `input` shape.
- * @see {@link DeleteFunctionCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteFunctionCommand extends $Command<DeleteFunctionCommandInput, DeleteFunctionCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: DeleteFunctionCommandInput;
     constructor(input: DeleteFunctionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionCommandInput, DeleteFunctionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DeleteKeyGroupCommandInput extends DeleteKeyGroupRequest {
 }
 export interface DeleteKeyGroupCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a key group.</p>
- * 		       <p>You cannot delete a key group that is referenced in a cache behavior. First update
- * 			your distributions to remove the key group from all cache behaviors, then delete the key
- * 			group.</p>
- * 		       <p>To delete a key group, you must provide the key group’s identifier and version. To get
- * 			these values, use <code>ListKeyGroups</code> followed by <code>GetKeyGroup</code> or
- * 			<code>GetKeyGroupConfig</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, DeleteKeyGroupCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, DeleteKeyGroupCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new DeleteKeyGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteKeyGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteKeyGroupCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteKeyGroupCommand extends $Command<DeleteKeyGroupCommandInput, DeleteKeyGroupCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: DeleteKeyGroupCommandInput;
     constructor(input: DeleteKeyGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteKeyGroupCommandInput, DeleteKeyGroupCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,35 +6,11 @@ export interface DeleteOriginRequestPolicyCommandInput extends DeleteOriginReque
 }
 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/ts3.4/commands/DeletePublicKeyCommand.d.ts

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

@@ -6,35 +6,11 @@ export interface DeleteRealtimeLogConfigCommandInput extends DeleteRealtimeLogCo
 }
 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/ts3.4/commands/DeleteStreamingDistributionCommand.d.ts

@@ -6,76 +6,11 @@ export interface DeleteStreamingDistributionCommandInput extends DeleteStreaming
 }
 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;