@aws-sdk/client-redshift-serverless 3.478.0 → 3.484.0

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

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

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

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

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

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

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

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

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