@aws-sdk/client-cloudfront 3.32.0 → 3.36.0

package/commands/CreateFieldLevelEncryptionProfileCommand.ts

@@ -1,102 +0,0 @@
-import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
-import { CreateFieldLevelEncryptionProfileRequest, CreateFieldLevelEncryptionProfileResult } from "../models/models_0";
-import {
-  deserializeAws_restXmlCreateFieldLevelEncryptionProfileCommand,
-  serializeAws_restXmlCreateFieldLevelEncryptionProfileCommand,
-} from "../protocols/Aws_restXml";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateFieldLevelEncryptionProfileCommandInput extends CreateFieldLevelEncryptionProfileRequest {}
-export interface CreateFieldLevelEncryptionProfileCommandOutput
-  extends CreateFieldLevelEncryptionProfileResult,
-    __MetadataBearer {}
-
-/**
- * <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.
- *
- */
-export class CreateFieldLevelEncryptionProfileCommand extends $Command<
-  CreateFieldLevelEncryptionProfileCommandInput,
-  CreateFieldLevelEncryptionProfileCommandOutput,
-  CloudFrontClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateFieldLevelEncryptionProfileCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudFrontClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateFieldLevelEncryptionProfileCommandInput, CreateFieldLevelEncryptionProfileCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudFrontClient";
-    const commandName = "CreateFieldLevelEncryptionProfileCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateFieldLevelEncryptionProfileRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateFieldLevelEncryptionProfileResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(
-    input: CreateFieldLevelEncryptionProfileCommandInput,
-    context: __SerdeContext
-  ): Promise<__HttpRequest> {
-    return serializeAws_restXmlCreateFieldLevelEncryptionProfileCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateFieldLevelEncryptionProfileCommandOutput> {
-    return deserializeAws_restXmlCreateFieldLevelEncryptionProfileCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateFunctionCommand.ts

@@ -1,104 +0,0 @@
-import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
-import { CreateFunctionRequest, CreateFunctionResult } from "../models/models_0";
-import {
-  deserializeAws_restXmlCreateFunctionCommand,
-  serializeAws_restXmlCreateFunctionCommand,
-} from "../protocols/Aws_restXml";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateFunctionCommandInput extends CreateFunctionRequest {}
-export interface CreateFunctionCommandOutput extends CreateFunctionResult, __MetadataBearer {}
-
-/**
- * <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.
- *
- */
-export class CreateFunctionCommand extends $Command<
-  CreateFunctionCommandInput,
-  CreateFunctionCommandOutput,
-  CloudFrontClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateFunctionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudFrontClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateFunctionCommandInput, CreateFunctionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudFrontClient";
-    const commandName = "CreateFunctionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateFunctionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateFunctionResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateFunctionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restXmlCreateFunctionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateFunctionCommandOutput> {
-    return deserializeAws_restXmlCreateFunctionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateInvalidationCommand.ts

@@ -1,94 +0,0 @@
-import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
-import { CreateInvalidationRequest, CreateInvalidationResult } from "../models/models_0";
-import {
-  deserializeAws_restXmlCreateInvalidationCommand,
-  serializeAws_restXmlCreateInvalidationCommand,
-} from "../protocols/Aws_restXml";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateInvalidationCommandInput extends CreateInvalidationRequest {}
-export interface CreateInvalidationCommandOutput extends CreateInvalidationResult, __MetadataBearer {}
-
-/**
- * <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.
- *
- */
-export class CreateInvalidationCommand extends $Command<
-  CreateInvalidationCommandInput,
-  CreateInvalidationCommandOutput,
-  CloudFrontClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateInvalidationCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudFrontClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateInvalidationCommandInput, CreateInvalidationCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudFrontClient";
-    const commandName = "CreateInvalidationCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateInvalidationRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateInvalidationResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateInvalidationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restXmlCreateInvalidationCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateInvalidationCommandOutput> {
-    return deserializeAws_restXmlCreateInvalidationCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateKeyGroupCommand.ts

@@ -1,101 +0,0 @@
-import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
-import { CreateKeyGroupRequest, CreateKeyGroupResult } from "../models/models_0";
-import {
-  deserializeAws_restXmlCreateKeyGroupCommand,
-  serializeAws_restXmlCreateKeyGroupCommand,
-} from "../protocols/Aws_restXml";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateKeyGroupCommandInput extends CreateKeyGroupRequest {}
-export interface CreateKeyGroupCommandOutput extends CreateKeyGroupResult, __MetadataBearer {}
-
-/**
- * <p>Creates a key group that you can use with <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html">CloudFront signed URLs and signed cookies</a>.</p>
- * 		       <p>To create a key group, you must specify at least one public key for the key group. After you
- * 			create a key group, you can reference it from one or more cache behaviors. When you
- * 			reference a key group in a cache behavior, CloudFront requires signed URLs or signed cookies
- * 			for all requests that match the cache behavior. The URLs or cookies must be signed with
- * 			a private key whose corresponding public key is in the key group. The signed URL or
- * 			cookie contains information about which public key CloudFront should use to verify the
- * 			signature. For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html">Serving private content</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, CreateKeyGroupCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, CreateKeyGroupCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new CreateKeyGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateKeyGroupCommandInput} for command's `input` shape.
- * @see {@link CreateKeyGroupCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateKeyGroupCommand extends $Command<
-  CreateKeyGroupCommandInput,
-  CreateKeyGroupCommandOutput,
-  CloudFrontClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateKeyGroupCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudFrontClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateKeyGroupCommandInput, CreateKeyGroupCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudFrontClient";
-    const commandName = "CreateKeyGroupCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateKeyGroupRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateKeyGroupResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateKeyGroupCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restXmlCreateKeyGroupCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateKeyGroupCommandOutput> {
-    return deserializeAws_restXmlCreateKeyGroupCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateMonitoringSubscriptionCommand.ts

@@ -1,102 +0,0 @@
-import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
-import { CreateMonitoringSubscriptionRequest, CreateMonitoringSubscriptionResult } from "../models/models_0";
-import {
-  deserializeAws_restXmlCreateMonitoringSubscriptionCommand,
-  serializeAws_restXmlCreateMonitoringSubscriptionCommand,
-} from "../protocols/Aws_restXml";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateMonitoringSubscriptionCommandInput extends CreateMonitoringSubscriptionRequest {}
-export interface CreateMonitoringSubscriptionCommandOutput
-  extends CreateMonitoringSubscriptionResult,
-    __MetadataBearer {}
-
-/**
- * <p>Enables additional CloudWatch metrics for the specified CloudFront distribution. The
- * 			additional metrics incur an additional cost.</p>
- * 		       <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/viewing-cloudfront-metrics.html#monitoring-console.distributions-additional">Viewing additional CloudFront distribution metrics</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, CreateMonitoringSubscriptionCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, CreateMonitoringSubscriptionCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new CreateMonitoringSubscriptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateMonitoringSubscriptionCommandInput} for command's `input` shape.
- * @see {@link CreateMonitoringSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateMonitoringSubscriptionCommand extends $Command<
-  CreateMonitoringSubscriptionCommandInput,
-  CreateMonitoringSubscriptionCommandOutput,
-  CloudFrontClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateMonitoringSubscriptionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudFrontClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateMonitoringSubscriptionCommandInput, CreateMonitoringSubscriptionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudFrontClient";
-    const commandName = "CreateMonitoringSubscriptionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateMonitoringSubscriptionRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateMonitoringSubscriptionResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateMonitoringSubscriptionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restXmlCreateMonitoringSubscriptionCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateMonitoringSubscriptionCommandOutput> {
-    return deserializeAws_restXmlCreateMonitoringSubscriptionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateOriginRequestPolicyCommand.ts

@@ -1,121 +0,0 @@
-import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
-import { CreateOriginRequestPolicyRequest, CreateOriginRequestPolicyResult } from "../models/models_0";
-import {
-  deserializeAws_restXmlCreateOriginRequestPolicyCommand,
-  serializeAws_restXmlCreateOriginRequestPolicyCommand,
-} from "../protocols/Aws_restXml";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateOriginRequestPolicyCommandInput extends CreateOriginRequestPolicyRequest {}
-export interface CreateOriginRequestPolicyCommandOutput extends CreateOriginRequestPolicyResult, __MetadataBearer {}
-
-/**
- * <p>Creates an origin request policy.</p>
- * 		       <p>After you create an origin request policy, you can attach it to one or more cache behaviors.
- * 			When it’s attached to a cache behavior, the origin request policy determines the values
- * 			that CloudFront includes in requests that it sends to the origin. Each request that CloudFront sends
- * 			to the origin includes the following:</p>
- * 		       <ul>
- *             <li>
- * 				           <p>The request body and the URL path (without the domain name) from the viewer
- * 					request.</p>
- * 			         </li>
- *             <li>
- * 				           <p>The headers that CloudFront automatically includes in every origin request, including
- * 					<code>Host</code>, <code>User-Agent</code>, and <code>X-Amz-Cf-Id</code>.</p>
- * 			         </li>
- *             <li>
- * 				           <p>All HTTP headers, cookies, and URL query strings that are specified in the cache policy or
- * 					the origin request policy. These can include items from the viewer request and,
- * 					in the case of headers, additional ones that are added by CloudFront.</p>
- * 			         </li>
- *          </ul>
- * 		       <p>CloudFront sends a request when it can’t find a valid object in its cache that matches the
- * 			request. If you want to send values to the origin and also include them in the cache
- * 			key, use <code>CachePolicy</code>.</p>
- * 		       <p>For more information about origin request policies, see <a href="https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/controlling-origin-requests.html">Controlling origin requests</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, CreateOriginRequestPolicyCommand } from "@aws-sdk/client-cloudfront"; // ES Modules import
- * // const { CloudFrontClient, CreateOriginRequestPolicyCommand } = require("@aws-sdk/client-cloudfront"); // CommonJS import
- * const client = new CloudFrontClient(config);
- * const command = new CreateOriginRequestPolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateOriginRequestPolicyCommandInput} for command's `input` shape.
- * @see {@link CreateOriginRequestPolicyCommandOutput} for command's `response` shape.
- * @see {@link CloudFrontClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateOriginRequestPolicyCommand extends $Command<
-  CreateOriginRequestPolicyCommandInput,
-  CreateOriginRequestPolicyCommandOutput,
-  CloudFrontClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateOriginRequestPolicyCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: CloudFrontClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateOriginRequestPolicyCommandInput, CreateOriginRequestPolicyCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "CloudFrontClient";
-    const commandName = "CreateOriginRequestPolicyCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateOriginRequestPolicyRequest.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateOriginRequestPolicyResult.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateOriginRequestPolicyCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_restXmlCreateOriginRequestPolicyCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateOriginRequestPolicyCommandOutput> {
-    return deserializeAws_restXmlCreateOriginRequestPolicyCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}