@aws-sdk/client-cloudfront 3.32.0 → 3.36.0

package/dist-cjs/CloudFrontClient.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudFrontClient = void 0;
+const config_resolver_1 = require("@aws-sdk/config-resolver");
+const middleware_content_length_1 = require("@aws-sdk/middleware-content-length");
+const middleware_host_header_1 = require("@aws-sdk/middleware-host-header");
+const middleware_logger_1 = require("@aws-sdk/middleware-logger");
+const middleware_retry_1 = require("@aws-sdk/middleware-retry");
+const middleware_signing_1 = require("@aws-sdk/middleware-signing");
+const middleware_user_agent_1 = require("@aws-sdk/middleware-user-agent");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const runtimeConfig_1 = require("./runtimeConfig");
+/**
+ * <fullname>Amazon CloudFront</fullname>
+ * 		       <p>This is the <i>Amazon CloudFront API Reference</i>. This guide
+ *             is for developers who need detailed information about
+ * 			CloudFront API actions, data types, and errors. For detailed information about CloudFront features, see the <i>Amazon CloudFront Developer Guide</i>.</p>
+ */
+class CloudFrontClient extends smithy_client_1.Client {
+    constructor(configuration) {
+        const _config_0 = runtimeConfig_1.getRuntimeConfig(configuration);
+        const _config_1 = config_resolver_1.resolveRegionConfig(_config_0);
+        const _config_2 = config_resolver_1.resolveEndpointsConfig(_config_1);
+        const _config_3 = middleware_retry_1.resolveRetryConfig(_config_2);
+        const _config_4 = middleware_host_header_1.resolveHostHeaderConfig(_config_3);
+        const _config_5 = middleware_signing_1.resolveAwsAuthConfig(_config_4);
+        const _config_6 = middleware_user_agent_1.resolveUserAgentConfig(_config_5);
+        super(_config_6);
+        this.config = _config_6;
+        this.middlewareStack.use(middleware_retry_1.getRetryPlugin(this.config));
+        this.middlewareStack.use(middleware_content_length_1.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middleware_host_header_1.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middleware_logger_1.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middleware_signing_1.getAwsAuthPlugin(this.config));
+        this.middlewareStack.use(middleware_user_agent_1.getUserAgentPlugin(this.config));
+    }
+    /**
+     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+     */
+    destroy() {
+        super.destroy();
+    }
+}
+exports.CloudFrontClient = CloudFrontClient;

package/dist-cjs/commands/AssociateAliasCommand.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssociateAliasCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Associates an alias (also known as a CNAME or an alternate domain name) with a CloudFront
+ * 			distribution.</p>
+ * 		       <p>With this operation you can move an alias that’s already in use on a CloudFront distribution
+ * 			to a different distribution in one step. This prevents the downtime that could occur if
+ * 			you first remove the alias from one distribution and then separately add the alias to
+ * 			another distribution.</p>
+ * 		       <p>To use this operation to associate an alias with a distribution, you provide the alias
+ * 			and the ID of the target distribution for the alias. For more information, including how
+ * 			to set up the target distribution, prerequisites that you must complete, and other
+ * 			restrictions, 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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, AssociateAliasCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, AssociateAliasCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new AssociateAliasCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AssociateAliasCommandInput} for command's `input` shape.
+ * @see {@link AssociateAliasCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class AssociateAliasCommand 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 = "AssociateAliasCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.AssociateAliasRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: (output) => output,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlAssociateAliasCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlAssociateAliasCommand(output, context);
+    }
+}
+exports.AssociateAliasCommand = AssociateAliasCommand;

package/dist-cjs/commands/CreateCachePolicyCommand.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCachePolicyCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Creates a cache policy.</p>
+ * 		       <p>After you create a cache policy, you can attach it to one or more cache behaviors. When it’s
+ * 			attached to a cache behavior, the cache policy determines the following:</p>
+ * 		       <ul>
+ *             <li>
+ * 				           <p>The values that CloudFront includes in the <i>cache key</i>. These values can
+ * 					include HTTP headers, cookies, and URL query strings. CloudFront uses the cache key to
+ * 					find an object in its cache that it can return to the viewer.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>The default, minimum, and maximum time to live (TTL) values that you want objects to stay
+ * 					in the CloudFront cache.</p>
+ * 			         </li>
+ *          </ul>
+ * 		       <p>The headers, cookies, and query strings that are included in the cache key are automatically
+ * 			included in requests that CloudFront sends to the origin. CloudFront sends a request when it can’t
+ * 			find an object in its cache that matches the request’s cache key. If you want to send
+ * 			values to the origin but <i>not</i> include them in the cache key, use
+ * 			<code>OriginRequestPolicy</code>.</p>
+ * 		       <p>For more information about cache policies, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/controlling-the-cache-key.html">Controlling the cache key</a> in the
+ * 			<i>Amazon CloudFront Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateCachePolicyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateCachePolicyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateCachePolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateCachePolicyCommandInput} for command's `input` shape.
+ * @see {@link CreateCachePolicyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateCachePolicyCommand 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 = "CreateCachePolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateCachePolicyRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateCachePolicyResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlCreateCachePolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlCreateCachePolicyCommand(output, context);
+    }
+}
+exports.CreateCachePolicyCommand = CreateCachePolicyCommand;

package/dist-cjs/commands/CreateCloudFrontOriginAccessIdentityCommand.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCloudFrontOriginAccessIdentityCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Creates a new origin access identity. If you're using Amazon S3 for your origin, you can
+ * 			use an origin access identity to require users to access your content using a CloudFront URL instead
+ * 			of the Amazon S3 URL. For more information about how to use origin access identities, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html">Serving Private Content through CloudFront</a> in the
+ * 				<i>Amazon CloudFront Developer Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateCloudFrontOriginAccessIdentityCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateCloudFrontOriginAccessIdentityCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateCloudFrontOriginAccessIdentityCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateCloudFrontOriginAccessIdentityCommandInput} for command's `input` shape.
+ * @see {@link CreateCloudFrontOriginAccessIdentityCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateCloudFrontOriginAccessIdentityCommand 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 = "CreateCloudFrontOriginAccessIdentityCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateCloudFrontOriginAccessIdentityRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateCloudFrontOriginAccessIdentityResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlCreateCloudFrontOriginAccessIdentityCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlCreateCloudFrontOriginAccessIdentityCommand(output, context);
+    }
+}
+exports.CreateCloudFrontOriginAccessIdentityCommand = CreateCloudFrontOriginAccessIdentityCommand;

package/dist-cjs/commands/CreateDistributionCommand.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDistributionCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Creates a new web distribution. You create a CloudFront distribution to tell CloudFront where you
+ * 			want content to be delivered from, and the details about how to track and manage content delivery. Send a <code>POST</code> request to the
+ * 			<code>/<i>CloudFront API version</i>/distribution</code>/<code>distribution ID</code> resource.</p>
+ * 		       <important>
+ *             <p>When you update a distribution, there are more required fields than when you create a distribution.
+ * 			When you update your distribution by using
+ * 			<a href="https://docs.aws.amazon.com/cloudfront/latest/APIReference/API_UpdateDistribution.html">UpdateDistribution</a>,
+ * 			follow the steps included
+ * 			in the documentation to get the current configuration
+ * 			and then make your updates. This helps to make sure that you include all of the required fields. To view a summary,
+ * 			see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/distribution-overview-required-fields.html">Required
+ * 				Fields for Create Distribution and Update Distribution</a> in the <i>Amazon CloudFront Developer Guide</i>.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateDistributionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateDistributionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateDistributionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDistributionCommandInput} for command's `input` shape.
+ * @see {@link CreateDistributionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateDistributionCommand 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 = "CreateDistributionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateDistributionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateDistributionResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlCreateDistributionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlCreateDistributionCommand(output, context);
+    }
+}
+exports.CreateDistributionCommand = CreateDistributionCommand;

package/dist-cjs/commands/CreateDistributionWithTagsCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDistributionWithTagsCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Create a new distribution with tags.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateDistributionWithTagsCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateDistributionWithTagsCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateDistributionWithTagsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateDistributionWithTagsCommandInput} for command's `input` shape.
+ * @see {@link CreateDistributionWithTagsCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateDistributionWithTagsCommand 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 = "CreateDistributionWithTagsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateDistributionWithTagsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateDistributionWithTagsResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlCreateDistributionWithTagsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlCreateDistributionWithTagsCommand(output, context);
+    }
+}
+exports.CreateDistributionWithTagsCommand = CreateDistributionWithTagsCommand;

package/dist-cjs/commands/CreateFieldLevelEncryptionConfigCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateFieldLevelEncryptionConfigCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Create a new field-level encryption configuration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateFieldLevelEncryptionConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateFieldLevelEncryptionConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateFieldLevelEncryptionConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateFieldLevelEncryptionConfigCommandInput} for command's `input` shape.
+ * @see {@link CreateFieldLevelEncryptionConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateFieldLevelEncryptionConfigCommand 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 = "CreateFieldLevelEncryptionConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateFieldLevelEncryptionConfigRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateFieldLevelEncryptionConfigResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlCreateFieldLevelEncryptionConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlCreateFieldLevelEncryptionConfigCommand(output, context);
+    }
+}
+exports.CreateFieldLevelEncryptionConfigCommand = CreateFieldLevelEncryptionConfigCommand;

package/dist-cjs/commands/CreateFieldLevelEncryptionProfileCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateFieldLevelEncryptionProfileCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Create a field-level encryption profile.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateFieldLevelEncryptionProfileCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateFieldLevelEncryptionProfileCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateFieldLevelEncryptionProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateFieldLevelEncryptionProfileCommandInput} for command's `input` shape.
+ * @see {@link CreateFieldLevelEncryptionProfileCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateFieldLevelEncryptionProfileCommand 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 = "CreateFieldLevelEncryptionProfileCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateFieldLevelEncryptionProfileRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateFieldLevelEncryptionProfileResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlCreateFieldLevelEncryptionProfileCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlCreateFieldLevelEncryptionProfileCommand(output, context);
+    }
+}
+exports.CreateFieldLevelEncryptionProfileCommand = CreateFieldLevelEncryptionProfileCommand;

package/dist-cjs/commands/CreateFunctionCommand.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateFunctionCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Creates a CloudFront function.</p>
+ * 		       <p>To create a function, you provide the function code and some configuration information
+ * 			about the function. The response contains an Amazon Resource Name (ARN) that uniquely
+ * 			identifies the function.</p>
+ * 		       <p>When you create a function, it’s in the <code>DEVELOPMENT</code> stage. In this stage, you
+ * 			can test the function with <code>TestFunction</code>, and update it with
+ * 			<code>UpdateFunction</code>.</p>
+ * 		       <p>When you’re ready to use your function with a CloudFront distribution, use
+ * 			<code>PublishFunction</code> to copy the function from the <code>DEVELOPMENT</code>
+ * 			stage to <code>LIVE</code>. When it’s live, you can attach the function to a
+ * 			distribution’s cache behavior, using the function’s ARN.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateFunctionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateFunctionCommandInput} for command's `input` shape.
+ * @see {@link CreateFunctionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateFunctionCommand 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 = "CreateFunctionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateFunctionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateFunctionResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlCreateFunctionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlCreateFunctionCommand(output, context);
+    }
+}
+exports.CreateFunctionCommand = CreateFunctionCommand;

package/dist-cjs/commands/CreateInvalidationCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateInvalidationCommand = void 0;
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restXml_1 = require("../protocols/Aws_restXml");
+/**
+ * <p>Create a new invalidation. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, CreateInvalidationCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, CreateInvalidationCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new CreateInvalidationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateInvalidationCommandInput} for command's `input` shape.
+ * @see {@link CreateInvalidationCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+class CreateInvalidationCommand 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 = "CreateInvalidationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateInvalidationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateInvalidationResult.filterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return Aws_restXml_1.serializeAws_restXmlCreateInvalidationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return Aws_restXml_1.deserializeAws_restXmlCreateInvalidationCommand(output, context);
+    }
+}
+exports.CreateInvalidationCommand = CreateInvalidationCommand;