@aws-sdk/client-cloudfront 3.32.0 → 3.36.0

package/dist-cjs/commands/GetRealtimeLogConfigCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetRealtimeLogConfigCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class GetRealtimeLogConfigCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetRealtimeLogConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.GetRealtimeLogConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.GetRealtimeLogConfigResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlGetRealtimeLogConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlGetRealtimeLogConfigCommand(output, context);
+    }
+}
+exports.GetRealtimeLogConfigCommand = GetRealtimeLogConfigCommand;

package/dist-cjs/commands/GetStreamingDistributionCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetStreamingDistributionCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class GetStreamingDistributionCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetStreamingDistributionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.GetStreamingDistributionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.GetStreamingDistributionResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlGetStreamingDistributionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlGetStreamingDistributionCommand(output, context);
+    }
+}
+exports.GetStreamingDistributionCommand = GetStreamingDistributionCommand;

package/dist-cjs/commands/GetStreamingDistributionConfigCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetStreamingDistributionConfigCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class GetStreamingDistributionConfigCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetStreamingDistributionConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.GetStreamingDistributionConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.GetStreamingDistributionConfigResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlGetStreamingDistributionConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlGetStreamingDistributionConfigCommand(output, context);
+    }
+}
+exports.GetStreamingDistributionConfigCommand = GetStreamingDistributionConfigCommand;

package/dist-cjs/commands/ListCachePoliciesCommand.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListCachePoliciesCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class ListCachePoliciesCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListCachePoliciesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.ListCachePoliciesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.ListCachePoliciesResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlListCachePoliciesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlListCachePoliciesCommand(output, context);
+    }
+}
+exports.ListCachePoliciesCommand = ListCachePoliciesCommand;

package/dist-cjs/commands/ListCloudFrontOriginAccessIdentitiesCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListCloudFrontOriginAccessIdentitiesCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class ListCloudFrontOriginAccessIdentitiesCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListCloudFrontOriginAccessIdentitiesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.ListCloudFrontOriginAccessIdentitiesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.ListCloudFrontOriginAccessIdentitiesResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlListCloudFrontOriginAccessIdentitiesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlListCloudFrontOriginAccessIdentitiesCommand(output, context);
+    }
+}
+exports.ListCloudFrontOriginAccessIdentitiesCommand = ListCloudFrontOriginAccessIdentitiesCommand;

package/dist-cjs/commands/ListConflictingAliasesCommand.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListConflictingAliasesCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class ListConflictingAliasesCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListConflictingAliasesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.ListConflictingAliasesRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.ListConflictingAliasesResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlListConflictingAliasesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlListConflictingAliasesCommand(output, context);
+    }
+}
+exports.ListConflictingAliasesCommand = ListConflictingAliasesCommand;

package/dist-cjs/commands/ListDistributionsByCachePolicyIdCommand.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDistributionsByCachePolicyIdCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class ListDistributionsByCachePolicyIdCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListDistributionsByCachePolicyIdCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.ListDistributionsByCachePolicyIdRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.ListDistributionsByCachePolicyIdResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlListDistributionsByCachePolicyIdCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlListDistributionsByCachePolicyIdCommand(output, context);
+    }
+}
+exports.ListDistributionsByCachePolicyIdCommand = ListDistributionsByCachePolicyIdCommand;

package/dist-cjs/commands/ListDistributionsByKeyGroupCommand.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDistributionsByKeyGroupCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class ListDistributionsByKeyGroupCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListDistributionsByKeyGroupCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.ListDistributionsByKeyGroupRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.ListDistributionsByKeyGroupResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlListDistributionsByKeyGroupCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlListDistributionsByKeyGroupCommand(output, context);
+    }
+}
+exports.ListDistributionsByKeyGroupCommand = ListDistributionsByKeyGroupCommand;

package/dist-cjs/commands/ListDistributionsByOriginRequestPolicyIdCommand.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListDistributionsByOriginRequestPolicyIdCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_1_1 = require("../models/models_1");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <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.
+ *
+ */
+class ListDistributionsByOriginRequestPolicyIdCommand extends smithy_client_1.Command {
+    // Start section: command_properties
+    // End section: command_properties
+    constructor(input) {
+        // Start section: command_constructor
+        super();
+        this.input = input;
+        // End section: command_constructor
+    }
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(middleware_serde_1.getSerdePlugin(configuration, this.serialize, this.deserialize));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListDistributionsByOriginRequestPolicyIdCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_1_1.ListDistributionsByOriginRequestPolicyIdRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_1_1.ListDistributionsByOriginRequestPolicyIdResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlListDistributionsByOriginRequestPolicyIdCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlListDistributionsByOriginRequestPolicyIdCommand(output, context);
+    }
+}
+exports.ListDistributionsByOriginRequestPolicyIdCommand = ListDistributionsByOriginRequestPolicyIdCommand;