@aws-sdk/client-auditmanager 3.478.0 → 3.484.0

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

package/dist-es/commands/BatchCreateDelegationByAssessmentCommand.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 { BatchCreateDelegationByAssessmentRequestFilterSensitiveLog, BatchCreateDelegationByAssessmentResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_BatchCreateDelegationByAssessmentCommand, se_BatchCreateDelegationByAssessmentCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class BatchCreateDelegationByAssessmentCommand 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, BatchCreateDelegationByAssessmentCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AuditManagerClient";
-        const commandName = "BatchCreateDelegationByAssessmentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: BatchCreateDelegationByAssessmentRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: BatchCreateDelegationByAssessmentResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "BedrockAssessmentManagerLambda",
-                operation: "BatchCreateDelegationByAssessment",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_BatchCreateDelegationByAssessmentCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_BatchCreateDelegationByAssessmentCommand(output, context);
-    }
+export class BatchCreateDelegationByAssessmentCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("BedrockAssessmentManagerLambda", "BatchCreateDelegationByAssessment", {})
+    .n("AuditManagerClient", "BatchCreateDelegationByAssessmentCommand")
+    .f(BatchCreateDelegationByAssessmentRequestFilterSensitiveLog, BatchCreateDelegationByAssessmentResponseFilterSensitiveLog)
+    .ser(se_BatchCreateDelegationByAssessmentCommand)
+    .de(de_BatchCreateDelegationByAssessmentCommand)
+    .build() {
 }

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

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

package/dist-es/commands/BatchImportEvidenceToAssessmentControlCommand.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 { BatchImportEvidenceToAssessmentControlRequestFilterSensitiveLog, BatchImportEvidenceToAssessmentControlResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_BatchImportEvidenceToAssessmentControlCommand, se_BatchImportEvidenceToAssessmentControlCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class BatchImportEvidenceToAssessmentControlCommand 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, BatchImportEvidenceToAssessmentControlCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AuditManagerClient";
-        const commandName = "BatchImportEvidenceToAssessmentControlCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: BatchImportEvidenceToAssessmentControlRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: BatchImportEvidenceToAssessmentControlResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "BedrockAssessmentManagerLambda",
-                operation: "BatchImportEvidenceToAssessmentControl",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_BatchImportEvidenceToAssessmentControlCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_BatchImportEvidenceToAssessmentControlCommand(output, context);
-    }
+export class BatchImportEvidenceToAssessmentControlCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("BedrockAssessmentManagerLambda", "BatchImportEvidenceToAssessmentControl", {})
+    .n("AuditManagerClient", "BatchImportEvidenceToAssessmentControlCommand")
+    .f(BatchImportEvidenceToAssessmentControlRequestFilterSensitiveLog, BatchImportEvidenceToAssessmentControlResponseFilterSensitiveLog)
+    .ser(se_BatchImportEvidenceToAssessmentControlCommand)
+    .de(de_BatchImportEvidenceToAssessmentControlCommand)
+    .build() {
 }

package/dist-es/commands/CreateAssessmentCommand.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 { CreateAssessmentRequestFilterSensitiveLog, CreateAssessmentResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_CreateAssessmentCommand, se_CreateAssessmentCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateAssessmentCommand 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, CreateAssessmentCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AuditManagerClient";
-        const commandName = "CreateAssessmentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: CreateAssessmentRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: CreateAssessmentResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "BedrockAssessmentManagerLambda",
-                operation: "CreateAssessment",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateAssessmentCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateAssessmentCommand(output, context);
-    }
+export class CreateAssessmentCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("BedrockAssessmentManagerLambda", "CreateAssessment", {})
+    .n("AuditManagerClient", "CreateAssessmentCommand")
+    .f(CreateAssessmentRequestFilterSensitiveLog, CreateAssessmentResponseFilterSensitiveLog)
+    .ser(se_CreateAssessmentCommand)
+    .de(de_CreateAssessmentCommand)
+    .build() {
 }

package/dist-es/commands/CreateAssessmentFrameworkCommand.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 { CreateAssessmentFrameworkRequestFilterSensitiveLog, CreateAssessmentFrameworkResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_CreateAssessmentFrameworkCommand, se_CreateAssessmentFrameworkCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateAssessmentFrameworkCommand 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, CreateAssessmentFrameworkCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AuditManagerClient";
-        const commandName = "CreateAssessmentFrameworkCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: CreateAssessmentFrameworkRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: CreateAssessmentFrameworkResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "BedrockAssessmentManagerLambda",
-                operation: "CreateAssessmentFramework",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateAssessmentFrameworkCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateAssessmentFrameworkCommand(output, context);
-    }
+export class CreateAssessmentFrameworkCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("BedrockAssessmentManagerLambda", "CreateAssessmentFramework", {})
+    .n("AuditManagerClient", "CreateAssessmentFrameworkCommand")
+    .f(CreateAssessmentFrameworkRequestFilterSensitiveLog, CreateAssessmentFrameworkResponseFilterSensitiveLog)
+    .ser(se_CreateAssessmentFrameworkCommand)
+    .de(de_CreateAssessmentFrameworkCommand)
+    .build() {
 }

package/dist-es/commands/CreateAssessmentReportCommand.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 { CreateAssessmentReportRequestFilterSensitiveLog, CreateAssessmentReportResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_CreateAssessmentReportCommand, se_CreateAssessmentReportCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateAssessmentReportCommand 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, CreateAssessmentReportCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AuditManagerClient";
-        const commandName = "CreateAssessmentReportCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: CreateAssessmentReportRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: CreateAssessmentReportResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "BedrockAssessmentManagerLambda",
-                operation: "CreateAssessmentReport",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateAssessmentReportCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateAssessmentReportCommand(output, context);
-    }
+export class CreateAssessmentReportCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("BedrockAssessmentManagerLambda", "CreateAssessmentReport", {})
+    .n("AuditManagerClient", "CreateAssessmentReportCommand")
+    .f(CreateAssessmentReportRequestFilterSensitiveLog, CreateAssessmentReportResponseFilterSensitiveLog)
+    .ser(se_CreateAssessmentReportCommand)
+    .de(de_CreateAssessmentReportCommand)
+    .build() {
 }

package/dist-es/commands/CreateControlCommand.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 { CreateControlRequestFilterSensitiveLog, CreateControlResponseFilterSensitiveLog, } from "../models/models_0";
 import { de_CreateControlCommand, se_CreateControlCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateControlCommand 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, CreateControlCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AuditManagerClient";
-        const commandName = "CreateControlCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: CreateControlRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: CreateControlResponseFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "BedrockAssessmentManagerLambda",
-                operation: "CreateControl",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_CreateControlCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_CreateControlCommand(output, context);
-    }
+export class CreateControlCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("BedrockAssessmentManagerLambda", "CreateControl", {})
+    .n("AuditManagerClient", "CreateControlCommand")
+    .f(CreateControlRequestFilterSensitiveLog, CreateControlResponseFilterSensitiveLog)
+    .ser(se_CreateControlCommand)
+    .de(de_CreateControlCommand)
+    .build() {
 }