@aws-sdk/client-cloudfront 3.478.0 → 3.484.0

package/dist-es/commands/UpdateOriginAccessControlCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UpdateOriginAccessControlCommand, se_UpdateOriginAccessControlCommand } from "../protocols/Aws_restXml";
 export { $Command };
-export class UpdateOriginAccessControlCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateOriginAccessControlCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "UpdateOriginAccessControlCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "Cloudfront2020_05_31",
-                operation: "UpdateOriginAccessControl",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UpdateOriginAccessControlCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UpdateOriginAccessControlCommand(output, context);
-    }
+export class UpdateOriginAccessControlCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Cloudfront2020_05_31", "UpdateOriginAccessControl", {})
+    .n("CloudFrontClient", "UpdateOriginAccessControlCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateOriginAccessControlCommand)
+    .de(de_UpdateOriginAccessControlCommand)
+    .build() {
 }

package/dist-es/commands/UpdateOriginRequestPolicyCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UpdateOriginRequestPolicyCommand, se_UpdateOriginRequestPolicyCommand } from "../protocols/Aws_restXml";
 export { $Command };
-export class UpdateOriginRequestPolicyCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateOriginRequestPolicyCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "UpdateOriginRequestPolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "Cloudfront2020_05_31",
-                operation: "UpdateOriginRequestPolicy",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UpdateOriginRequestPolicyCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UpdateOriginRequestPolicyCommand(output, context);
-    }
+export class UpdateOriginRequestPolicyCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Cloudfront2020_05_31", "UpdateOriginRequestPolicy", {})
+    .n("CloudFrontClient", "UpdateOriginRequestPolicyCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateOriginRequestPolicyCommand)
+    .de(de_UpdateOriginRequestPolicyCommand)
+    .build() {
 }

package/dist-es/commands/UpdatePublicKeyCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UpdatePublicKeyCommand, se_UpdatePublicKeyCommand } from "../protocols/Aws_restXml";
 export { $Command };
-export class UpdatePublicKeyCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdatePublicKeyCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "UpdatePublicKeyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "Cloudfront2020_05_31",
-                operation: "UpdatePublicKey",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UpdatePublicKeyCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UpdatePublicKeyCommand(output, context);
-    }
+export class UpdatePublicKeyCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Cloudfront2020_05_31", "UpdatePublicKey", {})
+    .n("CloudFrontClient", "UpdatePublicKeyCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdatePublicKeyCommand)
+    .de(de_UpdatePublicKeyCommand)
+    .build() {
 }

package/dist-es/commands/UpdateRealtimeLogConfigCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UpdateRealtimeLogConfigCommand, se_UpdateRealtimeLogConfigCommand } from "../protocols/Aws_restXml";
 export { $Command };
-export class UpdateRealtimeLogConfigCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateRealtimeLogConfigCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "UpdateRealtimeLogConfigCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "Cloudfront2020_05_31",
-                operation: "UpdateRealtimeLogConfig",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UpdateRealtimeLogConfigCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UpdateRealtimeLogConfigCommand(output, context);
-    }
+export class UpdateRealtimeLogConfigCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Cloudfront2020_05_31", "UpdateRealtimeLogConfig", {})
+    .n("CloudFrontClient", "UpdateRealtimeLogConfigCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateRealtimeLogConfigCommand)
+    .de(de_UpdateRealtimeLogConfigCommand)
+    .build() {
 }

package/dist-es/commands/UpdateResponseHeadersPolicyCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UpdateResponseHeadersPolicyCommand, se_UpdateResponseHeadersPolicyCommand } from "../protocols/Aws_restXml";
 export { $Command };
-export class UpdateResponseHeadersPolicyCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateResponseHeadersPolicyCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "UpdateResponseHeadersPolicyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "Cloudfront2020_05_31",
-                operation: "UpdateResponseHeadersPolicy",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UpdateResponseHeadersPolicyCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UpdateResponseHeadersPolicyCommand(output, context);
-    }
+export class UpdateResponseHeadersPolicyCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Cloudfront2020_05_31", "UpdateResponseHeadersPolicy", {})
+    .n("CloudFrontClient", "UpdateResponseHeadersPolicyCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateResponseHeadersPolicyCommand)
+    .de(de_UpdateResponseHeadersPolicyCommand)
+    .build() {
 }

package/dist-es/commands/UpdateStreamingDistributionCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UpdateStreamingDistributionCommand, se_UpdateStreamingDistributionCommand } from "../protocols/Aws_restXml";
 export { $Command };
-export class UpdateStreamingDistributionCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateStreamingDistributionCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CloudFrontClient";
-        const commandName = "UpdateStreamingDistributionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "Cloudfront2020_05_31",
-                operation: "UpdateStreamingDistribution",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UpdateStreamingDistributionCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UpdateStreamingDistributionCommand(output, context);
-    }
+export class UpdateStreamingDistributionCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("Cloudfront2020_05_31", "UpdateStreamingDistribution", {})
+    .n("CloudFrontClient", "UpdateStreamingDistributionCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateStreamingDistributionCommand)
+    .de(de_UpdateStreamingDistributionCommand)
+    .build() {
 }

package/dist-es/endpoint/EndpointParameters.js

@@ -6,3 +6,9 @@ export const resolveClientEndpointParameters = (options) => {
         defaultSigningName: "cloudfront",
     };
 };
+export const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+};

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
 import { AssociateAliasRequest } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface AssociateAliasCommandInput extends AssociateAliasRequest {
  */
 export interface AssociateAliasCommandOutput extends __MetadataBearer {
 }
+declare const AssociateAliasCommand_base: {
+    new (input: AssociateAliasCommandInput): import("@smithy/smithy-client").CommandImpl<AssociateAliasCommandInput, AssociateAliasCommandOutput, CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Associates an alias (also known as a CNAME or an alternate domain name) with a CloudFront
@@ -75,23 +78,5 @@ export interface AssociateAliasCommandOutput extends __MetadataBearer {
  * <p>Base exception class for all service exceptions from CloudFront service.</p>
  *
  */
-export declare class AssociateAliasCommand extends $Command<AssociateAliasCommandInput, AssociateAliasCommandOutput, CloudFrontClientResolvedConfig> {
-    readonly input: AssociateAliasCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: AssociateAliasCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateAliasCommandInput, AssociateAliasCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class AssociateAliasCommand extends AssociateAliasCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
 import { CopyDistributionRequest, CopyDistributionResult } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CopyDistributionCommandInput extends CopyDistributionRequest {
  */
 export interface CopyDistributionCommandOutput extends CopyDistributionResult, __MetadataBearer {
 }
+declare const CopyDistributionCommand_base: {
+    new (input: CopyDistributionCommandInput): import("@smithy/smithy-client").CommandImpl<CopyDistributionCommandInput, CopyDistributionCommandOutput, CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates a staging distribution using the configuration of the provided primary
@@ -643,23 +646,5 @@ export interface CopyDistributionCommandOutput extends CopyDistributionResult, _
  * <p>Base exception class for all service exceptions from CloudFront service.</p>
  *
  */
-export declare class CopyDistributionCommand extends $Command<CopyDistributionCommandInput, CopyDistributionCommandOutput, CloudFrontClientResolvedConfig> {
-    readonly input: CopyDistributionCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CopyDistributionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CopyDistributionCommandInput, CopyDistributionCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CopyDistributionCommand extends CopyDistributionCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
 import { CreateCachePolicyRequest, CreateCachePolicyResult } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateCachePolicyCommandInput extends CreateCachePolicyRequest
  */
 export interface CreateCachePolicyCommandOutput extends CreateCachePolicyResult, __MetadataBearer {
 }
+declare const CreateCachePolicyCommand_base: {
+    new (input: CreateCachePolicyCommandInput): import("@smithy/smithy-client").CommandImpl<CreateCachePolicyCommandInput, CreateCachePolicyCommandOutput, CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates a cache policy.</p>
@@ -187,23 +190,5 @@ export interface CreateCachePolicyCommandOutput extends CreateCachePolicyResult,
  * <p>Base exception class for all service exceptions from CloudFront service.</p>
  *
  */
-export declare class CreateCachePolicyCommand extends $Command<CreateCachePolicyCommandInput, CreateCachePolicyCommandOutput, CloudFrontClientResolvedConfig> {
-    readonly input: CreateCachePolicyCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateCachePolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCachePolicyCommandInput, CreateCachePolicyCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateCachePolicyCommand extends CreateCachePolicyCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
 import { CreateCloudFrontOriginAccessIdentityRequest, CreateCloudFrontOriginAccessIdentityResult } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateCloudFrontOriginAccessIdentityCommandInput extends Create
  */
 export interface CreateCloudFrontOriginAccessIdentityCommandOutput extends CreateCloudFrontOriginAccessIdentityResult, __MetadataBearer {
 }
+declare const CreateCloudFrontOriginAccessIdentityCommand_base: {
+    new (input: CreateCloudFrontOriginAccessIdentityCommandInput): import("@smithy/smithy-client").CommandImpl<CreateCloudFrontOriginAccessIdentityCommandInput, CreateCloudFrontOriginAccessIdentityCommandOutput, CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates a new origin access identity. If you're using Amazon S3 for your origin, you can
@@ -89,23 +92,5 @@ export interface CreateCloudFrontOriginAccessIdentityCommandOutput extends Creat
  * <p>Base exception class for all service exceptions from CloudFront service.</p>
  *
  */
-export declare class CreateCloudFrontOriginAccessIdentityCommand extends $Command<CreateCloudFrontOriginAccessIdentityCommandInput, CreateCloudFrontOriginAccessIdentityCommandOutput, CloudFrontClientResolvedConfig> {
-    readonly input: CreateCloudFrontOriginAccessIdentityCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateCloudFrontOriginAccessIdentityCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateCloudFrontOriginAccessIdentityCommandInput, CreateCloudFrontOriginAccessIdentityCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateCloudFrontOriginAccessIdentityCommand extends CreateCloudFrontOriginAccessIdentityCommand_base {
 }

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

@@ -1,6 +1,5 @@
-import { EndpointParameterInstructions } from "@smithy/middleware-endpoint";
 import { Command as $Command } from "@smithy/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@smithy/types";
+import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CloudFrontClient";
 import { CreateContinuousDeploymentPolicyRequest, CreateContinuousDeploymentPolicyResult } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateContinuousDeploymentPolicyCommandInput extends CreateCont
  */
 export interface CreateContinuousDeploymentPolicyCommandOutput extends CreateContinuousDeploymentPolicyResult, __MetadataBearer {
 }
+declare const CreateContinuousDeploymentPolicyCommand_base: {
+    new (input: CreateContinuousDeploymentPolicyCommandInput): import("@smithy/smithy-client").CommandImpl<CreateContinuousDeploymentPolicyCommandInput, CreateContinuousDeploymentPolicyCommandOutput, CloudFrontClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates a continuous deployment policy that distributes traffic for a custom domain
@@ -129,23 +132,5 @@ export interface CreateContinuousDeploymentPolicyCommandOutput extends CreateCon
  * <p>Base exception class for all service exceptions from CloudFront service.</p>
  *
  */
-export declare class CreateContinuousDeploymentPolicyCommand extends $Command<CreateContinuousDeploymentPolicyCommandInput, CreateContinuousDeploymentPolicyCommandOutput, CloudFrontClientResolvedConfig> {
-    readonly input: CreateContinuousDeploymentPolicyCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateContinuousDeploymentPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CloudFrontClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateContinuousDeploymentPolicyCommandInput, CreateContinuousDeploymentPolicyCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateContinuousDeploymentPolicyCommand extends CreateContinuousDeploymentPolicyCommand_base {
 }