@aws-sdk/client-cognito-identity-provider 3.478.0 → 3.481.0

package/dist-es/commands/AdminDeleteUserAttributesCommand.js

@@ -2,49 +2,26 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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 { AdminDeleteUserAttributesRequestFilterSensitiveLog, } from "../models/models_0";
 import { de_AdminDeleteUserAttributesCommand, se_AdminDeleteUserAttributesCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminDeleteUserAttributesCommand 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, AdminDeleteUserAttributesCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminDeleteUserAttributesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: AdminDeleteUserAttributesRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminDeleteUserAttributes",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminDeleteUserAttributesCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminDeleteUserAttributesCommand(output, context);
-    }
+export class AdminDeleteUserAttributesCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminDeleteUserAttributes", {})
+    .n("CognitoIdentityProviderClient", "AdminDeleteUserAttributesCommand")
+    .f(AdminDeleteUserAttributesRequestFilterSensitiveLog, void 0)
+    .ser(se_AdminDeleteUserAttributesCommand)
+    .de(de_AdminDeleteUserAttributesCommand)
+    .build() {
 }

package/dist-es/commands/AdminDeleteUserCommand.js

@@ -2,49 +2,26 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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 { AdminDeleteUserRequestFilterSensitiveLog } from "../models/models_0";
 import { de_AdminDeleteUserCommand, se_AdminDeleteUserCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminDeleteUserCommand 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, AdminDeleteUserCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminDeleteUserCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: AdminDeleteUserRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminDeleteUser",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminDeleteUserCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminDeleteUserCommand(output, context);
-    }
+export class AdminDeleteUserCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminDeleteUser", {})
+    .n("CognitoIdentityProviderClient", "AdminDeleteUserCommand")
+    .f(AdminDeleteUserRequestFilterSensitiveLog, void 0)
+    .ser(se_AdminDeleteUserCommand)
+    .de(de_AdminDeleteUserCommand)
+    .build() {
 }

package/dist-es/commands/AdminDisableProviderForUserCommand.js

@@ -2,48 +2,25 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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_AdminDisableProviderForUserCommand, se_AdminDisableProviderForUserCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminDisableProviderForUserCommand 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, AdminDisableProviderForUserCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminDisableProviderForUserCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminDisableProviderForUser",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminDisableProviderForUserCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminDisableProviderForUserCommand(output, context);
-    }
+export class AdminDisableProviderForUserCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminDisableProviderForUser", {})
+    .n("CognitoIdentityProviderClient", "AdminDisableProviderForUserCommand")
+    .f(void 0, void 0)
+    .ser(se_AdminDisableProviderForUserCommand)
+    .de(de_AdminDisableProviderForUserCommand)
+    .build() {
 }

package/dist-es/commands/AdminDisableUserCommand.js

@@ -2,49 +2,26 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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 { AdminDisableUserRequestFilterSensitiveLog, } from "../models/models_0";
 import { de_AdminDisableUserCommand, se_AdminDisableUserCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminDisableUserCommand 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, AdminDisableUserCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminDisableUserCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: AdminDisableUserRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminDisableUser",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminDisableUserCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminDisableUserCommand(output, context);
-    }
+export class AdminDisableUserCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminDisableUser", {})
+    .n("CognitoIdentityProviderClient", "AdminDisableUserCommand")
+    .f(AdminDisableUserRequestFilterSensitiveLog, void 0)
+    .ser(se_AdminDisableUserCommand)
+    .de(de_AdminDisableUserCommand)
+    .build() {
 }

package/dist-es/commands/AdminEnableUserCommand.js

@@ -2,49 +2,26 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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 { AdminEnableUserRequestFilterSensitiveLog, } from "../models/models_0";
 import { de_AdminEnableUserCommand, se_AdminEnableUserCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminEnableUserCommand 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, AdminEnableUserCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminEnableUserCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: AdminEnableUserRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminEnableUser",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminEnableUserCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminEnableUserCommand(output, context);
-    }
+export class AdminEnableUserCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminEnableUser", {})
+    .n("CognitoIdentityProviderClient", "AdminEnableUserCommand")
+    .f(AdminEnableUserRequestFilterSensitiveLog, void 0)
+    .ser(se_AdminEnableUserCommand)
+    .de(de_AdminEnableUserCommand)
+    .build() {
 }

package/dist-es/commands/AdminForgetDeviceCommand.js

@@ -2,49 +2,26 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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 { AdminForgetDeviceRequestFilterSensitiveLog } from "../models/models_0";
 import { de_AdminForgetDeviceCommand, se_AdminForgetDeviceCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminForgetDeviceCommand 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, AdminForgetDeviceCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminForgetDeviceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: AdminForgetDeviceRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminForgetDevice",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminForgetDeviceCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminForgetDeviceCommand(output, context);
-    }
+export class AdminForgetDeviceCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminForgetDevice", {})
+    .n("CognitoIdentityProviderClient", "AdminForgetDeviceCommand")
+    .f(AdminForgetDeviceRequestFilterSensitiveLog, void 0)
+    .ser(se_AdminForgetDeviceCommand)
+    .de(de_AdminForgetDeviceCommand)
+    .build() {
 }

package/dist-es/commands/AdminGetDeviceCommand.js

@@ -2,49 +2,26 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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 { AdminGetDeviceRequestFilterSensitiveLog, AdminGetDeviceResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_AdminGetDeviceCommand, se_AdminGetDeviceCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminGetDeviceCommand 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, AdminGetDeviceCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminGetDeviceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: AdminGetDeviceRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: AdminGetDeviceResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminGetDevice",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminGetDeviceCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminGetDeviceCommand(output, context);
-    }
+export class AdminGetDeviceCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminGetDevice", {})
+    .n("CognitoIdentityProviderClient", "AdminGetDeviceCommand")
+    .f(AdminGetDeviceRequestFilterSensitiveLog, AdminGetDeviceResponseFilterSensitiveLog)
+    .ser(se_AdminGetDeviceCommand)
+    .de(de_AdminGetDeviceCommand)
+    .build() {
 }

package/dist-es/commands/AdminGetUserCommand.js

@@ -2,49 +2,26 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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 { AdminGetUserRequestFilterSensitiveLog, AdminGetUserResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_AdminGetUserCommand, se_AdminGetUserCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminGetUserCommand 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, AdminGetUserCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminGetUserCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: AdminGetUserRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: AdminGetUserResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminGetUser",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminGetUserCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminGetUserCommand(output, context);
-    }
+export class AdminGetUserCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminGetUser", {})
+    .n("CognitoIdentityProviderClient", "AdminGetUserCommand")
+    .f(AdminGetUserRequestFilterSensitiveLog, AdminGetUserResponseFilterSensitiveLog)
+    .ser(se_AdminGetUserCommand)
+    .de(de_AdminGetUserCommand)
+    .build() {
 }

package/dist-es/commands/AdminInitiateAuthCommand.js

@@ -2,49 +2,26 @@ import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 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 { AdminInitiateAuthRequestFilterSensitiveLog, AdminInitiateAuthResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_AdminInitiateAuthCommand, se_AdminInitiateAuthCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class AdminInitiateAuthCommand 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, AdminInitiateAuthCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "AdminInitiateAuthCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: AdminInitiateAuthRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: AdminInitiateAuthResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "AdminInitiateAuth",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_AdminInitiateAuthCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_AdminInitiateAuthCommand(output, context);
-    }
+export class AdminInitiateAuthCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getAwsAuthPlugin(config),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "AdminInitiateAuth", {})
+    .n("CognitoIdentityProviderClient", "AdminInitiateAuthCommand")
+    .f(AdminInitiateAuthRequestFilterSensitiveLog, AdminInitiateAuthResponseFilterSensitiveLog)
+    .ser(se_AdminInitiateAuthCommand)
+    .de(de_AdminInitiateAuthCommand)
+    .build() {
 }