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

package/dist-es/commands/ListUsersCommand.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 { ListUsersResponseFilterSensitiveLog } from "../models/models_0";
 import { de_ListUsersCommand, se_ListUsersCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class ListUsersCommand 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, ListUsersCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "ListUsersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: ListUsersResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "ListUsers",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_ListUsersCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_ListUsersCommand(output, context);
-    }
+export class ListUsersCommand 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", "ListUsers", {})
+    .n("CognitoIdentityProviderClient", "ListUsersCommand")
+    .f(void 0, ListUsersResponseFilterSensitiveLog)
+    .ser(se_ListUsersCommand)
+    .de(de_ListUsersCommand)
+    .build() {
 }

package/dist-es/commands/ListUsersInGroupCommand.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 { ListUsersInGroupResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_ListUsersInGroupCommand, se_ListUsersInGroupCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class ListUsersInGroupCommand 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, ListUsersInGroupCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "ListUsersInGroupCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: ListUsersInGroupResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "ListUsersInGroup",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_ListUsersInGroupCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_ListUsersInGroupCommand(output, context);
-    }
+export class ListUsersInGroupCommand 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", "ListUsersInGroup", {})
+    .n("CognitoIdentityProviderClient", "ListUsersInGroupCommand")
+    .f(void 0, ListUsersInGroupResponseFilterSensitiveLog)
+    .ser(se_ListUsersInGroupCommand)
+    .de(de_ListUsersInGroupCommand)
+    .build() {
 }

package/dist-es/commands/ResendConfirmationCodeCommand.js

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

package/dist-es/commands/RespondToAuthChallengeCommand.js

@@ -1,48 +1,25 @@
 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 { RespondToAuthChallengeRequestFilterSensitiveLog, RespondToAuthChallengeResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_RespondToAuthChallengeCommand, se_RespondToAuthChallengeCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class RespondToAuthChallengeCommand 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, RespondToAuthChallengeCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "RespondToAuthChallengeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: RespondToAuthChallengeRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: RespondToAuthChallengeResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "RespondToAuthChallenge",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RespondToAuthChallengeCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RespondToAuthChallengeCommand(output, context);
-    }
+export class RespondToAuthChallengeCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AWSCognitoIdentityProviderService", "RespondToAuthChallenge", {})
+    .n("CognitoIdentityProviderClient", "RespondToAuthChallengeCommand")
+    .f(RespondToAuthChallengeRequestFilterSensitiveLog, RespondToAuthChallengeResponseFilterSensitiveLog)
+    .ser(se_RespondToAuthChallengeCommand)
+    .de(de_RespondToAuthChallengeCommand)
+    .build() {
 }

package/dist-es/commands/RevokeTokenCommand.js

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

package/dist-es/commands/SetLogDeliveryConfigurationCommand.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_SetLogDeliveryConfigurationCommand, se_SetLogDeliveryConfigurationCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class SetLogDeliveryConfigurationCommand 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, SetLogDeliveryConfigurationCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "SetLogDeliveryConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "SetLogDeliveryConfiguration",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SetLogDeliveryConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SetLogDeliveryConfigurationCommand(output, context);
-    }
+export class SetLogDeliveryConfigurationCommand 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", "SetLogDeliveryConfiguration", {})
+    .n("CognitoIdentityProviderClient", "SetLogDeliveryConfigurationCommand")
+    .f(void 0, void 0)
+    .ser(se_SetLogDeliveryConfigurationCommand)
+    .de(de_SetLogDeliveryConfigurationCommand)
+    .build() {
 }

package/dist-es/commands/SetRiskConfigurationCommand.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 { SetRiskConfigurationRequestFilterSensitiveLog, SetRiskConfigurationResponseFilterSensitiveLog, } from "../models/models_1";
 import { de_SetRiskConfigurationCommand, se_SetRiskConfigurationCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class SetRiskConfigurationCommand 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, SetRiskConfigurationCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "SetRiskConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: SetRiskConfigurationRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: SetRiskConfigurationResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "SetRiskConfiguration",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SetRiskConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SetRiskConfigurationCommand(output, context);
-    }
+export class SetRiskConfigurationCommand 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", "SetRiskConfiguration", {})
+    .n("CognitoIdentityProviderClient", "SetRiskConfigurationCommand")
+    .f(SetRiskConfigurationRequestFilterSensitiveLog, SetRiskConfigurationResponseFilterSensitiveLog)
+    .ser(se_SetRiskConfigurationCommand)
+    .de(de_SetRiskConfigurationCommand)
+    .build() {
 }

package/dist-es/commands/SetUICustomizationCommand.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 { SetUICustomizationRequestFilterSensitiveLog, SetUICustomizationResponseFilterSensitiveLog, } from "../models/models_1";
 import { de_SetUICustomizationCommand, se_SetUICustomizationCommand } from "../protocols/Aws_json1_1";
 export { $Command };
-export class SetUICustomizationCommand 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, SetUICustomizationCommand.getEndpointParameterInstructions()));
-        this.middlewareStack.use(getAwsAuthPlugin(configuration));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "CognitoIdentityProviderClient";
-        const commandName = "SetUICustomizationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: SetUICustomizationRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: SetUICustomizationResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AWSCognitoIdentityProviderService",
-                operation: "SetUICustomization",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SetUICustomizationCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SetUICustomizationCommand(output, context);
-    }
+export class SetUICustomizationCommand 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", "SetUICustomization", {})
+    .n("CognitoIdentityProviderClient", "SetUICustomizationCommand")
+    .f(SetUICustomizationRequestFilterSensitiveLog, SetUICustomizationResponseFilterSensitiveLog)
+    .ser(se_SetUICustomizationCommand)
+    .de(de_SetUICustomizationCommand)
+    .build() {
 }

package/dist-es/commands/SetUserMFAPreferenceCommand.js

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