@aws-sdk/client-cloudfront 3.32.0 → 3.36.0

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

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { PublishFunctionRequest, PublishFunctionResult } from "../models/models_1";
+export interface PublishFunctionCommandInput extends PublishFunctionRequest {
+}
+export interface PublishFunctionCommandOutput extends PublishFunctionResult, __MetadataBearer {
+}
+/**
+ * <p>Publishes a CloudFront function by copying the function code from the <code>DEVELOPMENT</code>
+ * 			stage to <code>LIVE</code>. This automatically updates all cache behaviors that are
+ * 			using this function to use the newly published copy in the <code>LIVE</code>
+ * 			stage.</p>
+ * 		       <p>When a function is published to the <code>LIVE</code> stage, you can attach the function to
+ * 			a distribution’s cache behavior, using the function’s Amazon Resource Name (ARN).</p>
+ * 		       <p>To publish a function, you must provide the function’s name and version (<code>ETag</code>
+ * 			value). To get these values, you can use <code>ListFunctions</code> and
+ * 			<code>DescribeFunction</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, PublishFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, PublishFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new PublishFunctionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PublishFunctionCommandInput} for command's `input` shape.
+ * @see {@link PublishFunctionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class PublishFunctionCommand extends $Command<PublishFunctionCommandInput, PublishFunctionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: PublishFunctionCommandInput;
+    constructor(input: PublishFunctionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PublishFunctionCommandInput, PublishFunctionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { UpdateFieldLevelEncryptionConfigRequest, UpdateFieldLevelEncryptionConfigResult } from "../models/models_1";
+export interface UpdateFieldLevelEncryptionConfigCommandInput extends UpdateFieldLevelEncryptionConfigRequest {
+}
+export interface UpdateFieldLevelEncryptionConfigCommandOutput extends UpdateFieldLevelEncryptionConfigResult, __MetadataBearer {
+}
+/**
+ * <p>Update a field-level encryption configuration. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, UpdateFieldLevelEncryptionConfigCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, UpdateFieldLevelEncryptionConfigCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new UpdateFieldLevelEncryptionConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateFieldLevelEncryptionConfigCommandInput} for command's `input` shape.
+ * @see {@link UpdateFieldLevelEncryptionConfigCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateFieldLevelEncryptionConfigCommand extends $Command<UpdateFieldLevelEncryptionConfigCommandInput, UpdateFieldLevelEncryptionConfigCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: UpdateFieldLevelEncryptionConfigCommandInput;
+    constructor(input: UpdateFieldLevelEncryptionConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFieldLevelEncryptionConfigCommandInput, UpdateFieldLevelEncryptionConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateFieldLevelEncryptionProfileCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { UpdateFieldLevelEncryptionProfileRequest, UpdateFieldLevelEncryptionProfileResult } from "../models/models_1";
+export interface UpdateFieldLevelEncryptionProfileCommandInput extends UpdateFieldLevelEncryptionProfileRequest {
+}
+export interface UpdateFieldLevelEncryptionProfileCommandOutput extends UpdateFieldLevelEncryptionProfileResult, __MetadataBearer {
+}
+/**
+ * <p>Update 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, UpdateFieldLevelEncryptionProfileCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, UpdateFieldLevelEncryptionProfileCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new UpdateFieldLevelEncryptionProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateFieldLevelEncryptionProfileCommandInput} for command's `input` shape.
+ * @see {@link UpdateFieldLevelEncryptionProfileCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateFieldLevelEncryptionProfileCommand extends $Command<UpdateFieldLevelEncryptionProfileCommandInput, UpdateFieldLevelEncryptionProfileCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: UpdateFieldLevelEncryptionProfileCommandInput;
+    constructor(input: UpdateFieldLevelEncryptionProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFieldLevelEncryptionProfileCommandInput, UpdateFieldLevelEncryptionProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateFunctionCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { UpdateFunctionRequest, UpdateFunctionResult } from "../models/models_1";
+export interface UpdateFunctionCommandInput extends UpdateFunctionRequest {
+}
+export interface UpdateFunctionCommandOutput extends UpdateFunctionResult, __MetadataBearer {
+}
+/**
+ * <p>Updates a CloudFront function.</p>
+ * 		       <p>You can update a function’s code or the comment that describes the function. You
+ * 			cannot update a function’s name.</p>
+ * 		       <p>To update a function, you provide the function’s name and version (<code>ETag</code> value)
+ * 			along with the updated function code. To get the name and version, you can use
+ * 			<code>ListFunctions</code> and <code>DescribeFunction</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, UpdateFunctionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, UpdateFunctionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new UpdateFunctionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateFunctionCommandInput} for command's `input` shape.
+ * @see {@link UpdateFunctionCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateFunctionCommand extends $Command<UpdateFunctionCommandInput, UpdateFunctionCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: UpdateFunctionCommandInput;
+    constructor(input: UpdateFunctionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFunctionCommandInput, UpdateFunctionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateKeyGroupCommand.d.ts

@@ -0,0 +1,52 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { UpdateKeyGroupRequest, UpdateKeyGroupResult } from "../models/models_1";
+export interface UpdateKeyGroupCommandInput extends UpdateKeyGroupRequest {
+}
+export interface UpdateKeyGroupCommandOutput extends UpdateKeyGroupResult, __MetadataBearer {
+}
+/**
+ * <p>Updates a key group.</p>
+ * 		       <p>When you update a key group, all the fields are updated with the values provided in
+ * 			the request. You cannot update some fields independent of others. To update a key
+ * 			group:</p>
+ * 		       <ol>
+ *             <li>
+ * 				           <p>Get the current key group with <code>GetKeyGroup</code> or
+ * 					<code>GetKeyGroupConfig</code>.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Locally modify the fields in the key group that you want to update. For
+ * 					example, add or remove public key IDs.</p>
+ * 			         </li>
+ *             <li>
+ * 				           <p>Call <code>UpdateKeyGroup</code> with the entire key group object, including
+ * 					the fields that you modified and those that you didn’t.</p>
+ * 			         </li>
+ *          </ol>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, UpdateKeyGroupCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, UpdateKeyGroupCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new UpdateKeyGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateKeyGroupCommandInput} for command's `input` shape.
+ * @see {@link UpdateKeyGroupCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateKeyGroupCommand extends $Command<UpdateKeyGroupCommandInput, UpdateKeyGroupCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: UpdateKeyGroupCommandInput;
+    constructor(input: UpdateKeyGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateKeyGroupCommandInput, UpdateKeyGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateOriginRequestPolicyCommand.d.ts

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

package/dist-types/commands/UpdatePublicKeyCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
+import { UpdatePublicKeyRequest, UpdatePublicKeyResult } from "../models/models_1";
+export interface UpdatePublicKeyCommandInput extends UpdatePublicKeyRequest {
+}
+export interface UpdatePublicKeyCommandOutput extends UpdatePublicKeyResult, __MetadataBearer {
+}
+/**
+ * <p>Update public key information. Note that the only value you can change is the comment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CloudFrontClient, UpdatePublicKeyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
+ * // const { CloudFrontClient, UpdatePublicKeyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
+ * const client = new CloudFrontClient(config);
+ * const command = new UpdatePublicKeyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdatePublicKeyCommandInput} for command's `input` shape.
+ * @see {@link UpdatePublicKeyCommandOutput} for command's `response` shape.
+ * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdatePublicKeyCommand extends $Command<UpdatePublicKeyCommandInput, UpdatePublicKeyCommandOutput, CloudFrontClientResolvedConfig> {
+    readonly input: UpdatePublicKeyCommandInput;
+    constructor(input: UpdatePublicKeyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdatePublicKeyCommandInput, UpdatePublicKeyCommandOutput>;
+    private serialize;
+    private deserialize;
+}