@aws-sdk/client-cloudfront 3.36.0 → 3.39.0

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface GetRealtimeLogConfigCommandInput extends GetRealtimeLogConfigRe
 }
 export interface GetRealtimeLogConfigCommandOutput extends GetRealtimeLogConfigResult, __MetadataBearer {
 }
-/**
- * <p>Gets a real-time log configuration.</p>
- * 		       <p>To get a real-time log configuration, you can provide the configuration’s name or its Amazon
- * 			Resource Name (ARN). You must provide at least one. If you provide both, CloudFront uses the
- * 			name to identify the real-time log configuration to get.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, GetRealtimeLogConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, GetRealtimeLogConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new GetRealtimeLogConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRealtimeLogConfigCommandInput} for command's `input` shape.
- * @see {@link GetRealtimeLogConfigCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetRealtimeLogConfigCommand extends $Command<GetRealtimeLogConfigCommandInput, GetRealtimeLogConfigCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: GetRealtimeLogConfigCommandInput;
     constructor(input: GetRealtimeLogConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRealtimeLogConfigCommandInput, GetRealtimeLogConfigCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,36 +6,11 @@ export interface ListCachePoliciesCommandInput extends ListCachePoliciesRequest
 }
 export interface ListCachePoliciesCommandOutput extends ListCachePoliciesResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of cache policies.</p>
- * 		       <p>You can optionally apply a filter to return only the managed policies created by Amazon Web Services, or
- * 			only the custom policies created in your account.</p>
- * 		       <p>You can optionally specify the maximum number of items to receive in the response. If
- * 			the total number of items in the list exceeds the maximum that you specify, or the
- * 			default maximum, the response is paginated. To get the next page of items, send a
- * 			subsequent request that specifies the <code>NextMarker</code> value from the current
- * 			response as the <code>Marker</code> value in the subsequent request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, ListCachePoliciesCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListCachePoliciesCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListCachePoliciesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListCachePoliciesCommandInput} for command's `input` shape.
- * @see {@link ListCachePoliciesCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListCachePoliciesCommand extends $Command<ListCachePoliciesCommandInput, ListCachePoliciesCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListCachePoliciesCommandInput;
     constructor(input: ListCachePoliciesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCachePoliciesCommandInput, ListCachePoliciesCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,51 +6,11 @@ export interface ListConflictingAliasesCommandInput extends ListConflictingAlias
 }
 export interface ListConflictingAliasesCommandOutput extends ListConflictingAliasesResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of aliases (also called CNAMEs or alternate domain names) that conflict or
- * 			overlap with the provided alias, and the associated CloudFront distributions and Amazon Web Services
- * 			accounts for each conflicting alias. In the returned list, the distribution and account
- * 			IDs are partially hidden, which allows you to identify the distributions and accounts
- * 			that you own, but helps to protect the information of ones that you don’t own.</p>
- * 		       <p>Use this operation to find aliases that are in use in CloudFront that conflict or overlap
- * 			with the provided alias. For example, if you provide <code>www.example.com</code> as
- * 			input, the returned list can include <code>www.example.com</code> and the overlapping
- * 			wildcard alternate domain name (<code>*.example.com</code>), if they exist. If you
- * 			provide <code>*.example.com</code> as input, the returned list can include
- * 			<code>*.example.com</code> and any alternate domain names covered by that wildcard (for
- * 			example, <code>www.example.com</code>, <code>test.example.com</code>,
- * 			<code>dev.example.com</code>, and so on), if they exist.</p>
- * 		       <p>To list conflicting aliases, you provide the alias to search and the ID of a distribution in
- * 			your account that has an attached SSL/TLS certificate that includes the provided alias.
- * 			For more information, including how to set up the distribution and certificate, see
- * 			<a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/CNAMEs.html#alternate-domain-names-move">Moving an alternate domain name to a different distribution</a>
- * 			in the <i>Amazon CloudFront Developer Guide</i>.</p>
- * 		       <p>You can optionally specify the maximum number of items to receive in the response. If
- * 			the total number of items in the list exceeds the maximum that you specify, or the
- * 			default maximum, the response is paginated. To get the next page of items, send a
- * 			subsequent request that specifies the <code>NextMarker</code> value from the current
- * 			response as the <code>Marker</code> value in the subsequent request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CloudFrontClient, ListConflictingAliasesCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListConflictingAliasesCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListConflictingAliasesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListConflictingAliasesCommandInput} for command's `input` shape.
- * @see {@link ListConflictingAliasesCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListConflictingAliasesCommand extends $Command<ListConflictingAliasesCommandInput, ListConflictingAliasesCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListConflictingAliasesCommandInput;
     constructor(input: ListConflictingAliasesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConflictingAliasesCommandInput, ListConflictingAliasesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface ListDistributionsByCachePolicyIdCommandInput extends ListDistri
 }
 export interface ListDistributionsByCachePolicyIdCommandOutput extends ListDistributionsByCachePolicyIdResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of distribution IDs for distributions that have a cache behavior that’s
- * 			associated with the specified cache policy.</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, ListDistributionsByCachePolicyIdCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListDistributionsByCachePolicyIdCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListDistributionsByCachePolicyIdCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDistributionsByCachePolicyIdCommandInput} for command's `input` shape.
- * @see {@link ListDistributionsByCachePolicyIdCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDistributionsByCachePolicyIdCommand extends $Command<ListDistributionsByCachePolicyIdCommandInput, ListDistributionsByCachePolicyIdCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListDistributionsByCachePolicyIdCommandInput;
     constructor(input: ListDistributionsByCachePolicyIdCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDistributionsByCachePolicyIdCommandInput, ListDistributionsByCachePolicyIdCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface ListDistributionsByKeyGroupCommandInput extends ListDistributio
 }
 export interface ListDistributionsByKeyGroupCommandOutput extends ListDistributionsByKeyGroupResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of distribution IDs for distributions that have a cache behavior that references
- * 			the specified key group.</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, ListDistributionsByKeyGroupCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListDistributionsByKeyGroupCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListDistributionsByKeyGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDistributionsByKeyGroupCommandInput} for command's `input` shape.
- * @see {@link ListDistributionsByKeyGroupCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDistributionsByKeyGroupCommand extends $Command<ListDistributionsByKeyGroupCommandInput, ListDistributionsByKeyGroupCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListDistributionsByKeyGroupCommandInput;
     constructor(input: ListDistributionsByKeyGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDistributionsByKeyGroupCommandInput, ListDistributionsByKeyGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface ListDistributionsByOriginRequestPolicyIdCommandInput extends Li
 }
 export interface ListDistributionsByOriginRequestPolicyIdCommandOutput extends ListDistributionsByOriginRequestPolicyIdResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of distribution IDs for distributions that have a cache behavior that’s
- * 			associated with the specified origin request policy.</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, ListDistributionsByOriginRequestPolicyIdCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListDistributionsByOriginRequestPolicyIdCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListDistributionsByOriginRequestPolicyIdCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDistributionsByOriginRequestPolicyIdCommandInput} for command's `input` shape.
- * @see {@link ListDistributionsByOriginRequestPolicyIdCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDistributionsByOriginRequestPolicyIdCommand extends $Command<ListDistributionsByOriginRequestPolicyIdCommandInput, ListDistributionsByOriginRequestPolicyIdCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListDistributionsByOriginRequestPolicyIdCommandInput;
     constructor(input: ListDistributionsByOriginRequestPolicyIdCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDistributionsByOriginRequestPolicyIdCommandInput, ListDistributionsByOriginRequestPolicyIdCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,38 +6,11 @@ export interface ListDistributionsByRealtimeLogConfigCommandInput extends ListDi
 }
 export interface ListDistributionsByRealtimeLogConfigCommandOutput extends ListDistributionsByRealtimeLogConfigResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of distributions that have a cache behavior that’s associated with the specified
- * 			real-time log configuration.</p>
- * 		       <p>You can specify the real-time log configuration by its 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 list distributions for.</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, ListDistributionsByRealtimeLogConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListDistributionsByRealtimeLogConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListDistributionsByRealtimeLogConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDistributionsByRealtimeLogConfigCommandInput} for command's `input` shape.
- * @see {@link ListDistributionsByRealtimeLogConfigCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDistributionsByRealtimeLogConfigCommand extends $Command<ListDistributionsByRealtimeLogConfigCommandInput, ListDistributionsByRealtimeLogConfigCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListDistributionsByRealtimeLogConfigCommandInput;
     constructor(input: ListDistributionsByRealtimeLogConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDistributionsByRealtimeLogConfigCommandInput, ListDistributionsByRealtimeLogConfigCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,36 +6,11 @@ export interface ListFunctionsCommandInput extends ListFunctionsRequest {
 }
 export interface ListFunctionsCommandOutput extends ListFunctionsResult, __MetadataBearer {
 }
-/**
- * <p>Gets a list of all CloudFront functions in your account.</p>
- * 		       <p>You can optionally apply a filter to return only the functions that are in the
- * 			specified stage, either <code>DEVELOPMENT</code> or <code>LIVE</code>.</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, ListFunctionsCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, ListFunctionsCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new ListFunctionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFunctionsCommandInput} for command's `input` shape.
- * @see {@link ListFunctionsCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFunctionsCommand extends $Command<ListFunctionsCommandInput, ListFunctionsCommandOutput, CloudFrontClientResolvedConfig> {
     readonly input: ListFunctionsCommandInput;
     constructor(input: ListFunctionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFunctionsCommandInput, ListFunctionsCommandOutput>;
     private serialize;
     private deserialize;