@aws-sdk/client-cloudfront 3.212.0 → 3.214.0

package/dist-es/CloudFront.js

@@ -1,7 +1,9 @@
 import { CloudFrontClient } from "./CloudFrontClient";
 import { AssociateAliasCommand, } from "./commands/AssociateAliasCommand";
+import { CopyDistributionCommand, } from "./commands/CopyDistributionCommand";
 import { CreateCachePolicyCommand, } from "./commands/CreateCachePolicyCommand";
 import { CreateCloudFrontOriginAccessIdentityCommand, } from "./commands/CreateCloudFrontOriginAccessIdentityCommand";
+import { CreateContinuousDeploymentPolicyCommand, } from "./commands/CreateContinuousDeploymentPolicyCommand";
 import { CreateDistributionCommand, } from "./commands/CreateDistributionCommand";
 import { CreateDistributionWithTagsCommand, } from "./commands/CreateDistributionWithTagsCommand";
 import { CreateFieldLevelEncryptionConfigCommand, } from "./commands/CreateFieldLevelEncryptionConfigCommand";
@@ -19,6 +21,7 @@ import { CreateStreamingDistributionCommand, } from "./commands/CreateStreamingD
 import { CreateStreamingDistributionWithTagsCommand, } from "./commands/CreateStreamingDistributionWithTagsCommand";
 import { DeleteCachePolicyCommand, } from "./commands/DeleteCachePolicyCommand";
 import { DeleteCloudFrontOriginAccessIdentityCommand, } from "./commands/DeleteCloudFrontOriginAccessIdentityCommand";
+import { DeleteContinuousDeploymentPolicyCommand, } from "./commands/DeleteContinuousDeploymentPolicyCommand";
 import { DeleteDistributionCommand, } from "./commands/DeleteDistributionCommand";
 import { DeleteFieldLevelEncryptionConfigCommand, } from "./commands/DeleteFieldLevelEncryptionConfigCommand";
 import { DeleteFieldLevelEncryptionProfileCommand, } from "./commands/DeleteFieldLevelEncryptionProfileCommand";
@@ -36,6 +39,8 @@ import { GetCachePolicyCommand, } from "./commands/GetCachePolicyCommand";
 import { GetCachePolicyConfigCommand, } from "./commands/GetCachePolicyConfigCommand";
 import { GetCloudFrontOriginAccessIdentityCommand, } from "./commands/GetCloudFrontOriginAccessIdentityCommand";
 import { GetCloudFrontOriginAccessIdentityConfigCommand, } from "./commands/GetCloudFrontOriginAccessIdentityConfigCommand";
+import { GetContinuousDeploymentPolicyCommand, } from "./commands/GetContinuousDeploymentPolicyCommand";
+import { GetContinuousDeploymentPolicyConfigCommand, } from "./commands/GetContinuousDeploymentPolicyConfigCommand";
 import { GetDistributionCommand, } from "./commands/GetDistributionCommand";
 import { GetDistributionConfigCommand, } from "./commands/GetDistributionConfigCommand";
 import { GetFieldLevelEncryptionCommand, } from "./commands/GetFieldLevelEncryptionCommand";
@@ -61,6 +66,7 @@ import { GetStreamingDistributionConfigCommand, } from "./commands/GetStreamingD
 import { ListCachePoliciesCommand, } from "./commands/ListCachePoliciesCommand";
 import { ListCloudFrontOriginAccessIdentitiesCommand, } from "./commands/ListCloudFrontOriginAccessIdentitiesCommand";
 import { ListConflictingAliasesCommand, } from "./commands/ListConflictingAliasesCommand";
+import { ListContinuousDeploymentPoliciesCommand, } from "./commands/ListContinuousDeploymentPoliciesCommand";
 import { ListDistributionsByCachePolicyIdCommand, } from "./commands/ListDistributionsByCachePolicyIdCommand";
 import { ListDistributionsByKeyGroupCommand, } from "./commands/ListDistributionsByKeyGroupCommand";
 import { ListDistributionsByOriginRequestPolicyIdCommand, } from "./commands/ListDistributionsByOriginRequestPolicyIdCommand";
@@ -86,6 +92,7 @@ import { TestFunctionCommand, } from "./commands/TestFunctionCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateCachePolicyCommand, } from "./commands/UpdateCachePolicyCommand";
 import { UpdateCloudFrontOriginAccessIdentityCommand, } from "./commands/UpdateCloudFrontOriginAccessIdentityCommand";
+import { UpdateContinuousDeploymentPolicyCommand, } from "./commands/UpdateContinuousDeploymentPolicyCommand";
 import { UpdateDistributionCommand, } from "./commands/UpdateDistributionCommand";
 import { UpdateFieldLevelEncryptionConfigCommand, } from "./commands/UpdateFieldLevelEncryptionConfigCommand";
 import { UpdateFieldLevelEncryptionProfileCommand, } from "./commands/UpdateFieldLevelEncryptionProfileCommand";
@@ -112,6 +119,20 @@ export class CloudFront extends CloudFrontClient {
             return this.send(command, optionsOrCb);
         }
     }
+    copyDistribution(args, optionsOrCb, cb) {
+        const command = new CopyDistributionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createCachePolicy(args, optionsOrCb, cb) {
         const command = new CreateCachePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -140,6 +161,20 @@ export class CloudFront extends CloudFrontClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createContinuousDeploymentPolicy(args, optionsOrCb, cb) {
+        const command = new CreateContinuousDeploymentPolicyCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createDistribution(args, optionsOrCb, cb) {
         const command = new CreateDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -378,6 +413,20 @@ export class CloudFront extends CloudFrontClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteContinuousDeploymentPolicy(args, optionsOrCb, cb) {
+        const command = new DeleteContinuousDeploymentPolicyCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteDistribution(args, optionsOrCb, cb) {
         const command = new DeleteDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -616,6 +665,34 @@ export class CloudFront extends CloudFrontClient {
             return this.send(command, optionsOrCb);
         }
     }
+    getContinuousDeploymentPolicy(args, optionsOrCb, cb) {
+        const command = new GetContinuousDeploymentPolicyCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    getContinuousDeploymentPolicyConfig(args, optionsOrCb, cb) {
+        const command = new GetContinuousDeploymentPolicyConfigCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     getDistribution(args, optionsOrCb, cb) {
         const command = new GetDistributionCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -966,6 +1043,20 @@ export class CloudFront extends CloudFrontClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listContinuousDeploymentPolicies(args, optionsOrCb, cb) {
+        const command = new ListContinuousDeploymentPoliciesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listDistributions(args, optionsOrCb, cb) {
         const command = new ListDistributionsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -1316,6 +1407,20 @@ export class CloudFront extends CloudFrontClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateContinuousDeploymentPolicy(args, optionsOrCb, cb) {
+        const command = new UpdateContinuousDeploymentPolicyCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     updateDistribution(args, optionsOrCb, cb) {
         const command = new UpdateDistributionCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/CopyDistributionCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CopyDistributionRequestFilterSensitiveLog, CopyDistributionResultFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restXmlCopyDistributionCommand, serializeAws_restXmlCopyDistributionCommand, } from "../protocols/Aws_restXml";
+export class CopyDistributionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CopyDistributionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "CopyDistributionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CopyDistributionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CopyDistributionResultFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restXmlCopyDistributionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restXmlCopyDistributionCommand(output, context);
+    }
+}

package/dist-es/commands/CreateContinuousDeploymentPolicyCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateContinuousDeploymentPolicyRequestFilterSensitiveLog, CreateContinuousDeploymentPolicyResultFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restXmlCreateContinuousDeploymentPolicyCommand, serializeAws_restXmlCreateContinuousDeploymentPolicyCommand, } from "../protocols/Aws_restXml";
+export class CreateContinuousDeploymentPolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateContinuousDeploymentPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "CreateContinuousDeploymentPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateContinuousDeploymentPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateContinuousDeploymentPolicyResultFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restXmlCreateContinuousDeploymentPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restXmlCreateContinuousDeploymentPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/CreateStreamingDistributionCommand.js

@@ -1,7 +1,7 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { CreateStreamingDistributionRequestFilterSensitiveLog, CreateStreamingDistributionResultFilterSensitiveLog, } from "../models/models_0";
+import { CreateStreamingDistributionRequestFilterSensitiveLog, CreateStreamingDistributionResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlCreateStreamingDistributionCommand, serializeAws_restXmlCreateStreamingDistributionCommand, } from "../protocols/Aws_restXml";
 export class CreateStreamingDistributionCommand extends $Command {
     constructor(input) {

package/dist-es/commands/CreateStreamingDistributionWithTagsCommand.js

@@ -1,7 +1,7 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { CreateStreamingDistributionWithTagsRequestFilterSensitiveLog, CreateStreamingDistributionWithTagsResultFilterSensitiveLog, } from "../models/models_0";
+import { CreateStreamingDistributionWithTagsRequestFilterSensitiveLog, CreateStreamingDistributionWithTagsResultFilterSensitiveLog, } from "../models/models_1";
 import { deserializeAws_restXmlCreateStreamingDistributionWithTagsCommand, serializeAws_restXmlCreateStreamingDistributionWithTagsCommand, } from "../protocols/Aws_restXml";
 export class CreateStreamingDistributionWithTagsCommand extends $Command {
     constructor(input) {

package/dist-es/commands/DeleteCachePolicyCommand.js

@@ -1,7 +1,7 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { DeleteCachePolicyRequestFilterSensitiveLog } from "../models/models_0";
+import { DeleteCachePolicyRequestFilterSensitiveLog } from "../models/models_1";
 import { deserializeAws_restXmlDeleteCachePolicyCommand, serializeAws_restXmlDeleteCachePolicyCommand, } from "../protocols/Aws_restXml";
 export class DeleteCachePolicyCommand extends $Command {
     constructor(input) {

package/dist-es/commands/DeleteContinuousDeploymentPolicyCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteContinuousDeploymentPolicyRequestFilterSensitiveLog, } from "../models/models_1";
+import { deserializeAws_restXmlDeleteContinuousDeploymentPolicyCommand, serializeAws_restXmlDeleteContinuousDeploymentPolicyCommand, } from "../protocols/Aws_restXml";
+export class DeleteContinuousDeploymentPolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteContinuousDeploymentPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "DeleteContinuousDeploymentPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteContinuousDeploymentPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: (output) => output,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restXmlDeleteContinuousDeploymentPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restXmlDeleteContinuousDeploymentPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/GetContinuousDeploymentPolicyCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetContinuousDeploymentPolicyRequestFilterSensitiveLog, GetContinuousDeploymentPolicyResultFilterSensitiveLog, } from "../models/models_1";
+import { deserializeAws_restXmlGetContinuousDeploymentPolicyCommand, serializeAws_restXmlGetContinuousDeploymentPolicyCommand, } from "../protocols/Aws_restXml";
+export class GetContinuousDeploymentPolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetContinuousDeploymentPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetContinuousDeploymentPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetContinuousDeploymentPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetContinuousDeploymentPolicyResultFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restXmlGetContinuousDeploymentPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restXmlGetContinuousDeploymentPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/GetContinuousDeploymentPolicyConfigCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetContinuousDeploymentPolicyConfigRequestFilterSensitiveLog, GetContinuousDeploymentPolicyConfigResultFilterSensitiveLog, } from "../models/models_1";
+import { deserializeAws_restXmlGetContinuousDeploymentPolicyConfigCommand, serializeAws_restXmlGetContinuousDeploymentPolicyConfigCommand, } from "../protocols/Aws_restXml";
+export class GetContinuousDeploymentPolicyConfigCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetContinuousDeploymentPolicyConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "GetContinuousDeploymentPolicyConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetContinuousDeploymentPolicyConfigRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetContinuousDeploymentPolicyConfigResultFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restXmlGetContinuousDeploymentPolicyConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restXmlGetContinuousDeploymentPolicyConfigCommand(output, context);
+    }
+}

package/dist-es/commands/ListContinuousDeploymentPoliciesCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListContinuousDeploymentPoliciesRequestFilterSensitiveLog, ListContinuousDeploymentPoliciesResultFilterSensitiveLog, } from "../models/models_1";
+import { deserializeAws_restXmlListContinuousDeploymentPoliciesCommand, serializeAws_restXmlListContinuousDeploymentPoliciesCommand, } from "../protocols/Aws_restXml";
+export class ListContinuousDeploymentPoliciesCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListContinuousDeploymentPoliciesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "ListContinuousDeploymentPoliciesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListContinuousDeploymentPoliciesRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListContinuousDeploymentPoliciesResultFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restXmlListContinuousDeploymentPoliciesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restXmlListContinuousDeploymentPoliciesCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateContinuousDeploymentPolicyCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateContinuousDeploymentPolicyRequestFilterSensitiveLog, UpdateContinuousDeploymentPolicyResultFilterSensitiveLog, } from "../models/models_1";
+import { deserializeAws_restXmlUpdateContinuousDeploymentPolicyCommand, serializeAws_restXmlUpdateContinuousDeploymentPolicyCommand, } from "../protocols/Aws_restXml";
+export class UpdateContinuousDeploymentPolicyCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateContinuousDeploymentPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CloudFrontClient";
+        const commandName = "UpdateContinuousDeploymentPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateContinuousDeploymentPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateContinuousDeploymentPolicyResultFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restXmlUpdateContinuousDeploymentPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restXmlUpdateContinuousDeploymentPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -1,6 +1,8 @@
 export * from "./AssociateAliasCommand";
+export * from "./CopyDistributionCommand";
 export * from "./CreateCachePolicyCommand";
 export * from "./CreateCloudFrontOriginAccessIdentityCommand";
+export * from "./CreateContinuousDeploymentPolicyCommand";
 export * from "./CreateDistributionCommand";
 export * from "./CreateDistributionWithTagsCommand";
 export * from "./CreateFieldLevelEncryptionConfigCommand";
@@ -18,6 +20,7 @@ export * from "./CreateStreamingDistributionCommand";
 export * from "./CreateStreamingDistributionWithTagsCommand";
 export * from "./DeleteCachePolicyCommand";
 export * from "./DeleteCloudFrontOriginAccessIdentityCommand";
+export * from "./DeleteContinuousDeploymentPolicyCommand";
 export * from "./DeleteDistributionCommand";
 export * from "./DeleteFieldLevelEncryptionConfigCommand";
 export * from "./DeleteFieldLevelEncryptionProfileCommand";
@@ -35,6 +38,8 @@ export * from "./GetCachePolicyCommand";
 export * from "./GetCachePolicyConfigCommand";
 export * from "./GetCloudFrontOriginAccessIdentityCommand";
 export * from "./GetCloudFrontOriginAccessIdentityConfigCommand";
+export * from "./GetContinuousDeploymentPolicyCommand";
+export * from "./GetContinuousDeploymentPolicyConfigCommand";
 export * from "./GetDistributionCommand";
 export * from "./GetDistributionConfigCommand";
 export * from "./GetFieldLevelEncryptionCommand";
@@ -60,6 +65,7 @@ export * from "./GetStreamingDistributionConfigCommand";
 export * from "./ListCachePoliciesCommand";
 export * from "./ListCloudFrontOriginAccessIdentitiesCommand";
 export * from "./ListConflictingAliasesCommand";
+export * from "./ListContinuousDeploymentPoliciesCommand";
 export * from "./ListDistributionsByCachePolicyIdCommand";
 export * from "./ListDistributionsByKeyGroupCommand";
 export * from "./ListDistributionsByOriginRequestPolicyIdCommand";
@@ -85,6 +91,7 @@ export * from "./TestFunctionCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateCachePolicyCommand";
 export * from "./UpdateCloudFrontOriginAccessIdentityCommand";
+export * from "./UpdateContinuousDeploymentPolicyCommand";
 export * from "./UpdateDistributionCommand";
 export * from "./UpdateFieldLevelEncryptionConfigCommand";
 export * from "./UpdateFieldLevelEncryptionProfileCommand";