@aws-sdk/client-cloudfront 3.36.0 → 3.39.0

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

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

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

@@ -6,34 +6,11 @@ export interface ListKeyGroupsCommandInput extends ListKeyGroupsRequest {
 }
 export interface ListKeyGroupsCommandOutput extends ListKeyGroupsResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of key groups.</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, ListKeyGroupsCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListKeyGroupsCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListKeyGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListKeyGroupsCommandInput} for command's `input` shape.
- * @see {@link ListKeyGroupsCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListKeyGroupsCommand extends $Command<ListKeyGroupsCommandInput, ListKeyGroupsCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListKeyGroupsCommandInput;
     constructor(input: ListKeyGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListKeyGroupsCommandInput, ListKeyGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface ListOriginRequestPoliciesCommandInput extends ListOriginRequest
 }
 export interface ListOriginRequestPoliciesCommandOutput extends ListOriginRequestPoliciesResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of origin request 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, ListOriginRequestPoliciesCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListOriginRequestPoliciesCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListOriginRequestPoliciesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListOriginRequestPoliciesCommandInput} for command's `input` shape.
- * @see {@link ListOriginRequestPoliciesCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListOriginRequestPoliciesCommand extends $Command<ListOriginRequestPoliciesCommandInput, ListOriginRequestPoliciesCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListOriginRequestPoliciesCommandInput;
     constructor(input: ListOriginRequestPoliciesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListOriginRequestPoliciesCommandInput, ListOriginRequestPoliciesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,34 +6,11 @@ export interface ListRealtimeLogConfigsCommandInput extends ListRealtimeLogConfi
 }
 export interface ListRealtimeLogConfigsCommandOutput extends ListRealtimeLogConfigsResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of real-time log configurations.</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, ListRealtimeLogConfigsCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListRealtimeLogConfigsCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListRealtimeLogConfigsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListRealtimeLogConfigsCommandInput} for command's `input` shape.
- * @see {@link ListRealtimeLogConfigsCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListRealtimeLogConfigsCommand extends $Command<ListRealtimeLogConfigsCommandInput, ListRealtimeLogConfigsCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListRealtimeLogConfigsCommandInput;
     constructor(input: ListRealtimeLogConfigsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRealtimeLogConfigsCommandInput, ListRealtimeLogConfigsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,37 +6,11 @@ export interface PublishFunctionCommandInput extends PublishFunctionRequest {
 }
 export interface PublishFunctionCommandOutput extends PublishFunctionResult, __MetadataBearer {
 }
-/**
- * <p>Publishes a CloudFront function by copying the function code from the <code>DEVELOPMENT</code>
- * 			stage to <code>LIVE</code>. This automatically updates all cache behaviors that are
- * 			using this function to use the newly published copy in the <code>LIVE</code>
- * 			stage.</p>
- * 		       <p>When a function is published to the <code>LIVE</code> stage, you can attach the function to
- * 			a distribution’s cache behavior, using the function’s Amazon Resource Name (ARN).</p>
- * 		       <p>To publish 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, PublishFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, PublishFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new PublishFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PublishFunctionCommandInput} for command's `input` shape.
- * @see {@link PublishFunctionCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PublishFunctionCommand extends $Command<PublishFunctionCommandInput, PublishFunctionCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: PublishFunctionCommandInput;
     constructor(input: PublishFunctionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PublishFunctionCommandInput, PublishFunctionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,38 +6,11 @@ export interface TestFunctionCommandInput extends TestFunctionRequest {
 }
 export interface TestFunctionCommandOutput extends TestFunctionResult, __MetadataBearer {
 }
-/**
- * <p>Tests a CloudFront function.</p>
- * 		       <p>To test a function, you provide an <i>event object</i> that represents an HTTP
- * 			request or response that your CloudFront distribution could receive in production. CloudFront runs
- * 			the function, passing it the event object that you provided, and returns the function’s
- * 			result (the modified event object) in the response. The response also contains function
- * 			logs and error messages, if any exist. For more information about testing functions, see
- * 			<a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/managing-functions.html#test-function">Testing functions</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>
- * 		       <p>To test a function, you provide the function’s name and version (<code>ETag</code> value)
- * 			along with the event object. To get the function’s name and version, 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, TestFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, TestFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new TestFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TestFunctionCommandInput} for command's `input` shape.
- * @see {@link TestFunctionCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TestFunctionCommand extends $Command<TestFunctionCommandInput, TestFunctionCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: TestFunctionCommandInput;
     constructor(input: TestFunctionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TestFunctionCommandInput, TestFunctionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,46 +6,11 @@ export interface UpdateCachePolicyCommandInput extends UpdateCachePolicyRequest
 }
 export interface UpdateCachePolicyCommandOutput extends UpdateCachePolicyResult, __MetadataBearer {
 }
-/**
- * <p>Updates a cache policy configuration.</p>
- * 		       <p>When you update a cache policy configuration, all the fields are updated with the
- * 			values provided in the request. You cannot update some fields independent of others. To
- * 			update a cache policy configuration:</p>
- * 		       <ol>
- *             <li>
- * 				           <p>Use <code>GetCachePolicyConfig</code> to get the current configuration.</p>
- * 			         </li>
- *             <li>
- * 				           <p>Locally modify the fields in the cache policy configuration that you want to
- * 					update.</p>
- * 			         </li>
- *             <li>
- * 				           <p>Call <code>UpdateCachePolicy</code> by providing the entire cache policy
- * 					configuration, including the fields that you modified and those that you
- * 					didn’t.</p>
- * 			         </li>
- *          </ol>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, UpdateCachePolicyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, UpdateCachePolicyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new UpdateCachePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateCachePolicyCommandInput} for command's `input` shape.
- * @see {@link UpdateCachePolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateCachePolicyCommand extends $Command<UpdateCachePolicyCommandInput, UpdateCachePolicyCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: UpdateCachePolicyCommandInput;
     constructor(input: UpdateCachePolicyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateCachePolicyCommandInput, UpdateCachePolicyCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,107 +6,11 @@ export interface UpdateDistributionCommandInput extends UpdateDistributionReques
 }
 export interface UpdateDistributionCommandOutput extends UpdateDistributionResult, __MetadataBearer {
 }
-/**
- * <p>Updates the configuration for a web distribution. </p>
- * 		       <important>
- *             <p>When you update a distribution, there are more required fields than when you create a distribution.
- * 			When you update your distribution by using this API action, follow the steps here to get the current configuration
- * 			and then make your updates, to make sure that you include all of the required fields. To view a summary,
- * 			see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-overview-required-fields.html">Required
- * 				Fields for Create Distribution and Update Distribution</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>
- *          </important>
- * 		       <p>The update process includes getting the current distribution configuration, updating the XML document that is
- * 			returned to make your changes, and then submitting an <code>UpdateDistribution</code> request to make the updates.</p>
- * 		       <p>For information about updating a distribution using the CloudFront console instead, see
- * 			<a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-web-creating-console.html">Creating a
- * 				Distribution</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>
- *
- * 		       <p>
- *             <b>To update a web distribution using the CloudFront API</b>
- *          </p>
- * 		       <ol>
- *             <li>
- *                <p>Submit a
- * 				<a href="https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_GetDistributionConfig.html">GetDistributionConfig</a>
- * 				request to get the current configuration and an <code>Etag</code> header
- * 				for the distribution.</p>
- * 				           <note>
- *                   <p>If you update the distribution again, you must get a new <code>Etag</code> header.</p>
- *                </note>
- * 			         </li>
- *             <li>
- *                <p>Update the XML document that was returned in the response to your <code>GetDistributionConfig</code> request to include
- * 				your changes. </p>
- * 				           <important>
- * 					             <p>When you edit the XML file, be aware of the following:</p>
- * 					             <ul>
- *                      <li>
- *                         <p>You must strip out the ETag parameter that is returned.</p>
- *                      </li>
- *                      <li>
- *                         <p>Additional fields are required when you update a distribution. There may be fields included in the
- * 							XML file for features that you haven't configured for your distribution. This is expected and required to
- * 							successfully update the distribution.</p>
- *                      </li>
- *                      <li>
- *                         <p>You can't change the value of <code>CallerReference</code>. If you try to change this value, CloudFront returns an
- * 							<code>IllegalUpdate</code> error. </p>
- *                      </li>
- *                      <li>
- *                         <p>The new configuration replaces the existing configuration; the values that you specify in an
- * 							<code>UpdateDistribution</code> request are not merged into your existing configuration. When you add, delete, or
- * 							replace values in an element that allows multiple values (for example, <code>CNAME</code>), you must specify all of the
- * 							values that you want to appear in the updated distribution. In addition,
- * 							you must update the corresponding <code>Quantity</code> element.</p>
- *                      </li>
- *                   </ul>
- *                </important>
- * 			         </li>
- *             <li>
- *                <p>Submit an <code>UpdateDistribution</code> request to update the configuration for your distribution:</p>
- * 				           <ul>
- *                   <li>
- *                      <p>In the request body, include the XML document that you updated in Step 2. The request body must include an
- * 						XML document with a <code>DistributionConfig</code> element.</p>
- *                   </li>
- *                   <li>
- *                      <p>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>GetDistributionConfig</code> request in Step 1.</p>
- *                   </li>
- *                </ul>
- * 			         </li>
- *             <li>
- *                <p>Review the response to the <code>UpdateDistribution</code> request to confirm that the configuration was
- * 				successfully updated.</p>
- *             </li>
- *             <li>
- *                <p>Optional: Submit a
- * 				<a href="https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_GetDistribution.html">GetDistribution</a>
- * 				request to confirm that your changes have propagated.
- * 				When propagation is complete, the value of <code>Status</code> is <code>Deployed</code>.</p>
- * 			         </li>
- *          </ol>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, UpdateDistributionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, UpdateDistributionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new UpdateDistributionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDistributionCommandInput} for command's `input` shape.
- * @see {@link UpdateDistributionCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDistributionCommand extends $Command<UpdateDistributionCommandInput, UpdateDistributionCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: UpdateDistributionCommandInput;
     constructor(input: UpdateDistributionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDistributionCommandInput, UpdateDistributionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateFieldLevelEncryptionConfigCommandInput extends UpdateFiel
 }
 export interface UpdateFieldLevelEncryptionConfigCommandOutput extends UpdateFieldLevelEncryptionConfigResult, __MetadataBearer {
 }
-/**
- * <p>Update 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, UpdateFieldLevelEncryptionConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, UpdateFieldLevelEncryptionConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new UpdateFieldLevelEncryptionConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateFieldLevelEncryptionConfigCommandInput} for command's `input` shape.
- * @see {@link UpdateFieldLevelEncryptionConfigCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateFieldLevelEncryptionConfigCommand extends $Command<UpdateFieldLevelEncryptionConfigCommandInput, UpdateFieldLevelEncryptionConfigCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: UpdateFieldLevelEncryptionConfigCommandInput;
     constructor(input: UpdateFieldLevelEncryptionConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFieldLevelEncryptionConfigCommandInput, UpdateFieldLevelEncryptionConfigCommandOutput>;
     private serialize;
     private deserialize;