@aws-sdk/client-elastic-load-balancing 3.478.0 → 3.484.0

package/dist-es/commands/RemoveTagsCommand.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_RemoveTagsCommand, se_RemoveTagsCommand } from "../protocols/Aws_query";
 export { $Command };
-export class RemoveTagsCommand 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, RemoveTagsCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ElasticLoadBalancingClient";
-        const commandName = "RemoveTagsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "ElasticLoadBalancing_v7",
-                operation: "RemoveTags",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RemoveTagsCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RemoveTagsCommand(output, context);
-    }
+export class RemoveTagsCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ElasticLoadBalancing_v7", "RemoveTags", {})
+    .n("ElasticLoadBalancingClient", "RemoveTagsCommand")
+    .f(void 0, void 0)
+    .ser(se_RemoveTagsCommand)
+    .de(de_RemoveTagsCommand)
+    .build() {
 }

package/dist-es/commands/SetLoadBalancerListenerSSLCertificateCommand.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_SetLoadBalancerListenerSSLCertificateCommand, se_SetLoadBalancerListenerSSLCertificateCommand, } from "../protocols/Aws_query";
 export { $Command };
-export class SetLoadBalancerListenerSSLCertificateCommand 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, SetLoadBalancerListenerSSLCertificateCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ElasticLoadBalancingClient";
-        const commandName = "SetLoadBalancerListenerSSLCertificateCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "ElasticLoadBalancing_v7",
-                operation: "SetLoadBalancerListenerSSLCertificate",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SetLoadBalancerListenerSSLCertificateCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SetLoadBalancerListenerSSLCertificateCommand(output, context);
-    }
+export class SetLoadBalancerListenerSSLCertificateCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ElasticLoadBalancing_v7", "SetLoadBalancerListenerSSLCertificate", {})
+    .n("ElasticLoadBalancingClient", "SetLoadBalancerListenerSSLCertificateCommand")
+    .f(void 0, void 0)
+    .ser(se_SetLoadBalancerListenerSSLCertificateCommand)
+    .de(de_SetLoadBalancerListenerSSLCertificateCommand)
+    .build() {
 }

package/dist-es/commands/SetLoadBalancerPoliciesForBackendServerCommand.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_SetLoadBalancerPoliciesForBackendServerCommand, se_SetLoadBalancerPoliciesForBackendServerCommand, } from "../protocols/Aws_query";
 export { $Command };
-export class SetLoadBalancerPoliciesForBackendServerCommand 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, SetLoadBalancerPoliciesForBackendServerCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ElasticLoadBalancingClient";
-        const commandName = "SetLoadBalancerPoliciesForBackendServerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "ElasticLoadBalancing_v7",
-                operation: "SetLoadBalancerPoliciesForBackendServer",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SetLoadBalancerPoliciesForBackendServerCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SetLoadBalancerPoliciesForBackendServerCommand(output, context);
-    }
+export class SetLoadBalancerPoliciesForBackendServerCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ElasticLoadBalancing_v7", "SetLoadBalancerPoliciesForBackendServer", {})
+    .n("ElasticLoadBalancingClient", "SetLoadBalancerPoliciesForBackendServerCommand")
+    .f(void 0, void 0)
+    .ser(se_SetLoadBalancerPoliciesForBackendServerCommand)
+    .de(de_SetLoadBalancerPoliciesForBackendServerCommand)
+    .build() {
 }

package/dist-es/commands/SetLoadBalancerPoliciesOfListenerCommand.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_SetLoadBalancerPoliciesOfListenerCommand, se_SetLoadBalancerPoliciesOfListenerCommand, } from "../protocols/Aws_query";
 export { $Command };
-export class SetLoadBalancerPoliciesOfListenerCommand 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, SetLoadBalancerPoliciesOfListenerCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "ElasticLoadBalancingClient";
-        const commandName = "SetLoadBalancerPoliciesOfListenerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "ElasticLoadBalancing_v7",
-                operation: "SetLoadBalancerPoliciesOfListener",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SetLoadBalancerPoliciesOfListenerCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SetLoadBalancerPoliciesOfListenerCommand(output, context);
-    }
+export class SetLoadBalancerPoliciesOfListenerCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("ElasticLoadBalancing_v7", "SetLoadBalancerPoliciesOfListener", {})
+    .n("ElasticLoadBalancingClient", "SetLoadBalancerPoliciesOfListenerCommand")
+    .f(void 0, void 0)
+    .ser(se_SetLoadBalancerPoliciesOfListenerCommand)
+    .de(de_SetLoadBalancerPoliciesOfListenerCommand)
+    .build() {
 }

package/dist-es/endpoint/EndpointParameters.js

@@ -6,3 +6,9 @@ export const resolveClientEndpointParameters = (options) => {
         defaultSigningName: "elasticloadbalancing",
     };
 };
+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/AddTagsCommand.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 { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
 import { AddTagsInput, AddTagsOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface AddTagsCommandInput extends AddTagsInput {
  */
 export interface AddTagsCommandOutput extends AddTagsOutput, __MetadataBearer {
 }
+declare const AddTagsCommand_base: {
+    new (input: AddTagsCommandInput): import("@smithy/smithy-client").CommandImpl<AddTagsCommandInput, AddTagsCommandOutput, ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Adds the specified tags to the specified load balancer. Each load balancer can have a maximum of 10 tags.</p>
@@ -95,23 +98,5 @@ export interface AddTagsCommandOutput extends AddTagsOutput, __MetadataBearer {
  * ```
  *
  */
-export declare class AddTagsCommand extends $Command<AddTagsCommandInput, AddTagsCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: AddTagsCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: AddTagsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddTagsCommandInput, AddTagsCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class AddTagsCommand extends AddTagsCommand_base {
 }

package/dist-types/commands/ApplySecurityGroupsToLoadBalancerCommand.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 { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
 import { ApplySecurityGroupsToLoadBalancerInput, ApplySecurityGroupsToLoadBalancerOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface ApplySecurityGroupsToLoadBalancerCommandInput extends ApplySecu
  */
 export interface ApplySecurityGroupsToLoadBalancerCommandOutput extends ApplySecurityGroupsToLoadBalancerOutput, __MetadataBearer {
 }
+declare const ApplySecurityGroupsToLoadBalancerCommand_base: {
+    new (input: ApplySecurityGroupsToLoadBalancerCommandInput): import("@smithy/smithy-client").CommandImpl<ApplySecurityGroupsToLoadBalancerCommandInput, ApplySecurityGroupsToLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Associates one or more security groups with your load balancer in a virtual private cloud (VPC). The specified security groups override the previously associated security groups.</p>
@@ -88,23 +91,5 @@ export interface ApplySecurityGroupsToLoadBalancerCommandOutput extends ApplySec
  * ```
  *
  */
-export declare class ApplySecurityGroupsToLoadBalancerCommand extends $Command<ApplySecurityGroupsToLoadBalancerCommandInput, ApplySecurityGroupsToLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: ApplySecurityGroupsToLoadBalancerCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: ApplySecurityGroupsToLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ApplySecurityGroupsToLoadBalancerCommandInput, ApplySecurityGroupsToLoadBalancerCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class ApplySecurityGroupsToLoadBalancerCommand extends ApplySecurityGroupsToLoadBalancerCommand_base {
 }

package/dist-types/commands/AttachLoadBalancerToSubnetsCommand.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 { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
 import { AttachLoadBalancerToSubnetsInput, AttachLoadBalancerToSubnetsOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface AttachLoadBalancerToSubnetsCommandInput extends AttachLoadBalan
  */
 export interface AttachLoadBalancerToSubnetsCommandOutput extends AttachLoadBalancerToSubnetsOutput, __MetadataBearer {
 }
+declare const AttachLoadBalancerToSubnetsCommand_base: {
+    new (input: AttachLoadBalancerToSubnetsCommandInput): import("@smithy/smithy-client").CommandImpl<AttachLoadBalancerToSubnetsCommandInput, AttachLoadBalancerToSubnetsCommandOutput, ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Adds one or more subnets to the set of configured subnets for the specified load balancer.</p>
@@ -93,23 +96,5 @@ export interface AttachLoadBalancerToSubnetsCommandOutput extends AttachLoadBala
  * ```
  *
  */
-export declare class AttachLoadBalancerToSubnetsCommand extends $Command<AttachLoadBalancerToSubnetsCommandInput, AttachLoadBalancerToSubnetsCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: AttachLoadBalancerToSubnetsCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: AttachLoadBalancerToSubnetsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AttachLoadBalancerToSubnetsCommandInput, AttachLoadBalancerToSubnetsCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class AttachLoadBalancerToSubnetsCommand extends AttachLoadBalancerToSubnetsCommand_base {
 }

package/dist-types/commands/ConfigureHealthCheckCommand.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 { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
 import { ConfigureHealthCheckInput, ConfigureHealthCheckOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface ConfigureHealthCheckCommandInput extends ConfigureHealthCheckIn
  */
 export interface ConfigureHealthCheckCommandOutput extends ConfigureHealthCheckOutput, __MetadataBearer {
 }
+declare const ConfigureHealthCheckCommand_base: {
+    new (input: ConfigureHealthCheckCommandInput): import("@smithy/smithy-client").CommandImpl<ConfigureHealthCheckCommandInput, ConfigureHealthCheckCommandOutput, ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Specifies the health check settings to use when evaluating the health state of your EC2 instances.</p>
@@ -98,23 +101,5 @@ export interface ConfigureHealthCheckCommandOutput extends ConfigureHealthCheckO
  * ```
  *
  */
-export declare class ConfigureHealthCheckCommand extends $Command<ConfigureHealthCheckCommandInput, ConfigureHealthCheckCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: ConfigureHealthCheckCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: ConfigureHealthCheckCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ConfigureHealthCheckCommandInput, ConfigureHealthCheckCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class ConfigureHealthCheckCommand extends ConfigureHealthCheckCommand_base {
 }

package/dist-types/commands/CreateAppCookieStickinessPolicyCommand.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 { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
 import { CreateAppCookieStickinessPolicyInput, CreateAppCookieStickinessPolicyOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateAppCookieStickinessPolicyCommandInput extends CreateAppCo
  */
 export interface CreateAppCookieStickinessPolicyCommandOutput extends CreateAppCookieStickinessPolicyOutput, __MetadataBearer {
 }
+declare const CreateAppCookieStickinessPolicyCommand_base: {
+    new (input: CreateAppCookieStickinessPolicyCommandInput): import("@smithy/smithy-client").CommandImpl<CreateAppCookieStickinessPolicyCommandInput, CreateAppCookieStickinessPolicyCommandOutput, ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Generates a stickiness policy with sticky session lifetimes that follow that of an application-generated cookie. This policy can be associated only with HTTP/HTTPS listeners.</p>
@@ -84,23 +87,5 @@ export interface CreateAppCookieStickinessPolicyCommandOutput extends CreateAppC
  * ```
  *
  */
-export declare class CreateAppCookieStickinessPolicyCommand extends $Command<CreateAppCookieStickinessPolicyCommandInput, CreateAppCookieStickinessPolicyCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: CreateAppCookieStickinessPolicyCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateAppCookieStickinessPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateAppCookieStickinessPolicyCommandInput, CreateAppCookieStickinessPolicyCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateAppCookieStickinessPolicyCommand extends CreateAppCookieStickinessPolicyCommand_base {
 }

package/dist-types/commands/CreateLBCookieStickinessPolicyCommand.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 { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
 import { CreateLBCookieStickinessPolicyInput, CreateLBCookieStickinessPolicyOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateLBCookieStickinessPolicyCommandInput extends CreateLBCook
  */
 export interface CreateLBCookieStickinessPolicyCommandOutput extends CreateLBCookieStickinessPolicyOutput, __MetadataBearer {
 }
+declare const CreateLBCookieStickinessPolicyCommand_base: {
+    new (input: CreateLBCookieStickinessPolicyCommandInput): import("@smithy/smithy-client").CommandImpl<CreateLBCookieStickinessPolicyCommandInput, CreateLBCookieStickinessPolicyCommandOutput, ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Generates a stickiness policy with sticky session lifetimes controlled by the lifetime of the browser (user-agent) or a specified expiration period. This policy can be associated only with HTTP/HTTPS listeners.</p>
@@ -82,23 +85,5 @@ export interface CreateLBCookieStickinessPolicyCommandOutput extends CreateLBCoo
  * ```
  *
  */
-export declare class CreateLBCookieStickinessPolicyCommand extends $Command<CreateLBCookieStickinessPolicyCommandInput, CreateLBCookieStickinessPolicyCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: CreateLBCookieStickinessPolicyCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateLBCookieStickinessPolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLBCookieStickinessPolicyCommandInput, CreateLBCookieStickinessPolicyCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateLBCookieStickinessPolicyCommand extends CreateLBCookieStickinessPolicyCommand_base {
 }

package/dist-types/commands/CreateLoadBalancerCommand.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 { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
 import { CreateAccessPointInput, CreateAccessPointOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateLoadBalancerCommandInput extends CreateAccessPointInput {
  */
 export interface CreateLoadBalancerCommandOutput extends CreateAccessPointOutput, __MetadataBearer {
 }
+declare const CreateLoadBalancerCommand_base: {
+    new (input: CreateLoadBalancerCommandInput): import("@smithy/smithy-client").CommandImpl<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates a Classic Load Balancer.</p>
@@ -286,23 +289,5 @@ export interface CreateLoadBalancerCommandOutput extends CreateAccessPointOutput
  * ```
  *
  */
-export declare class CreateLoadBalancerCommand extends $Command<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: CreateLoadBalancerCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateLoadBalancerCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerCommandInput, CreateLoadBalancerCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateLoadBalancerCommand extends CreateLoadBalancerCommand_base {
 }

package/dist-types/commands/CreateLoadBalancerListenersCommand.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 { ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticLoadBalancingClient";
 import { CreateLoadBalancerListenerInput, CreateLoadBalancerListenerOutput } from "../models/models_0";
 /**
@@ -21,6 +20,10 @@ export interface CreateLoadBalancerListenersCommandInput extends CreateLoadBalan
  */
 export interface CreateLoadBalancerListenersCommandOutput extends CreateLoadBalancerListenerOutput, __MetadataBearer {
 }
+declare const CreateLoadBalancerListenersCommand_base: {
+    new (input: CreateLoadBalancerListenersCommandInput): import("@smithy/smithy-client").CommandImpl<CreateLoadBalancerListenersCommandInput, CreateLoadBalancerListenersCommandOutput, ElasticLoadBalancingClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
 /**
  * @public
  * <p>Creates one or more listeners for the specified load balancer. If a listener with the specified port does not already exist, it is created; otherwise, the properties of the new listener must match the properties of the existing listener.</p>
@@ -116,23 +119,5 @@ export interface CreateLoadBalancerListenersCommandOutput extends CreateLoadBala
  * ```
  *
  */
-export declare class CreateLoadBalancerListenersCommand extends $Command<CreateLoadBalancerListenersCommandInput, CreateLoadBalancerListenersCommandOutput, ElasticLoadBalancingClientResolvedConfig> {
-    readonly input: CreateLoadBalancerListenersCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateLoadBalancerListenersCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticLoadBalancingClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoadBalancerListenersCommandInput, CreateLoadBalancerListenersCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
+export declare class CreateLoadBalancerListenersCommand extends CreateLoadBalancerListenersCommand_base {
 }