@aws-sdk/client-datazone 3.477.0 → 3.481.0

package/dist-es/commands/ListSubscriptionRequestsCommand.js

@@ -1,47 +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 { ListSubscriptionRequestsOutputFilterSensitiveLog, } from "../models/models_0";
 import { de_ListSubscriptionRequestsCommand, se_ListSubscriptionRequestsCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class ListSubscriptionRequestsCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, ListSubscriptionRequestsCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "ListSubscriptionRequestsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: ListSubscriptionRequestsOutputFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "ListSubscriptionRequests",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_ListSubscriptionRequestsCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_ListSubscriptionRequestsCommand(output, context);
-    }
+export class ListSubscriptionRequestsCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "ListSubscriptionRequests", {})
+    .n("DataZoneClient", "ListSubscriptionRequestsCommand")
+    .f(void 0, ListSubscriptionRequestsOutputFilterSensitiveLog)
+    .ser(se_ListSubscriptionRequestsCommand)
+    .de(de_ListSubscriptionRequestsCommand)
+    .build() {
 }

package/dist-es/commands/ListSubscriptionTargetsCommand.js

@@ -1,47 +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 { ListSubscriptionTargetsOutputFilterSensitiveLog } from "../models/models_1";
 import { de_ListSubscriptionTargetsCommand, se_ListSubscriptionTargetsCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class ListSubscriptionTargetsCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, ListSubscriptionTargetsCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "ListSubscriptionTargetsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: ListSubscriptionTargetsOutputFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "ListSubscriptionTargets",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_ListSubscriptionTargetsCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_ListSubscriptionTargetsCommand(output, context);
-    }
+export class ListSubscriptionTargetsCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "ListSubscriptionTargets", {})
+    .n("DataZoneClient", "ListSubscriptionTargetsCommand")
+    .f(void 0, ListSubscriptionTargetsOutputFilterSensitiveLog)
+    .ser(se_ListSubscriptionTargetsCommand)
+    .de(de_ListSubscriptionTargetsCommand)
+    .build() {
 }

package/dist-es/commands/ListSubscriptionsCommand.js

@@ -1,47 +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 { ListSubscriptionsOutputFilterSensitiveLog, } from "../models/models_0";
 import { de_ListSubscriptionsCommand, se_ListSubscriptionsCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class ListSubscriptionsCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, ListSubscriptionsCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "ListSubscriptionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: ListSubscriptionsOutputFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "ListSubscriptions",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_ListSubscriptionsCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_ListSubscriptionsCommand(output, context);
-    }
+export class ListSubscriptionsCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "ListSubscriptions", {})
+    .n("DataZoneClient", "ListSubscriptionsCommand")
+    .f(void 0, ListSubscriptionsOutputFilterSensitiveLog)
+    .ser(se_ListSubscriptionsCommand)
+    .de(de_ListSubscriptionsCommand)
+    .build() {
 }

package/dist-es/commands/ListTagsForResourceCommand.js

@@ -1,46 +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_ListTagsForResourceCommand, se_ListTagsForResourceCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class ListTagsForResourceCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, ListTagsForResourceCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "ListTagsForResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "ListTagsForResource",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_ListTagsForResourceCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_ListTagsForResourceCommand(output, context);
-    }
+export class ListTagsForResourceCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "ListTagsForResource", {})
+    .n("DataZoneClient", "ListTagsForResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_ListTagsForResourceCommand)
+    .de(de_ListTagsForResourceCommand)
+    .build() {
 }

package/dist-es/commands/PutEnvironmentBlueprintConfigurationCommand.js

@@ -1,46 +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_PutEnvironmentBlueprintConfigurationCommand, se_PutEnvironmentBlueprintConfigurationCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class PutEnvironmentBlueprintConfigurationCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, PutEnvironmentBlueprintConfigurationCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "PutEnvironmentBlueprintConfigurationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "PutEnvironmentBlueprintConfiguration",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_PutEnvironmentBlueprintConfigurationCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_PutEnvironmentBlueprintConfigurationCommand(output, context);
-    }
+export class PutEnvironmentBlueprintConfigurationCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "PutEnvironmentBlueprintConfiguration", {})
+    .n("DataZoneClient", "PutEnvironmentBlueprintConfigurationCommand")
+    .f(void 0, void 0)
+    .ser(se_PutEnvironmentBlueprintConfigurationCommand)
+    .de(de_PutEnvironmentBlueprintConfigurationCommand)
+    .build() {
 }

package/dist-es/commands/RejectPredictionsCommand.js

@@ -1,46 +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_RejectPredictionsCommand, se_RejectPredictionsCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class RejectPredictionsCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, RejectPredictionsCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "RejectPredictionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "RejectPredictions",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RejectPredictionsCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RejectPredictionsCommand(output, context);
-    }
+export class RejectPredictionsCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "RejectPredictions", {})
+    .n("DataZoneClient", "RejectPredictionsCommand")
+    .f(void 0, void 0)
+    .ser(se_RejectPredictionsCommand)
+    .de(de_RejectPredictionsCommand)
+    .build() {
 }

package/dist-es/commands/RejectSubscriptionRequestCommand.js

@@ -1,47 +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 { RejectSubscriptionRequestInputFilterSensitiveLog, RejectSubscriptionRequestOutputFilterSensitiveLog, } from "../models/models_1";
 import { de_RejectSubscriptionRequestCommand, se_RejectSubscriptionRequestCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class RejectSubscriptionRequestCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, RejectSubscriptionRequestCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "RejectSubscriptionRequestCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: RejectSubscriptionRequestInputFilterSensitiveLog,
-            outputFilterSensitiveLog: RejectSubscriptionRequestOutputFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "RejectSubscriptionRequest",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RejectSubscriptionRequestCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RejectSubscriptionRequestCommand(output, context);
-    }
+export class RejectSubscriptionRequestCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "RejectSubscriptionRequest", {})
+    .n("DataZoneClient", "RejectSubscriptionRequestCommand")
+    .f(RejectSubscriptionRequestInputFilterSensitiveLog, RejectSubscriptionRequestOutputFilterSensitiveLog)
+    .ser(se_RejectSubscriptionRequestCommand)
+    .de(de_RejectSubscriptionRequestCommand)
+    .build() {
 }

package/dist-es/commands/RevokeSubscriptionCommand.js

@@ -1,47 +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 { RevokeSubscriptionOutputFilterSensitiveLog, } from "../models/models_1";
 import { de_RevokeSubscriptionCommand, se_RevokeSubscriptionCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class RevokeSubscriptionCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, RevokeSubscriptionCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "RevokeSubscriptionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: RevokeSubscriptionOutputFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "RevokeSubscription",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RevokeSubscriptionCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RevokeSubscriptionCommand(output, context);
-    }
+export class RevokeSubscriptionCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "RevokeSubscription", {})
+    .n("DataZoneClient", "RevokeSubscriptionCommand")
+    .f(void 0, RevokeSubscriptionOutputFilterSensitiveLog)
+    .ser(se_RevokeSubscriptionCommand)
+    .de(de_RevokeSubscriptionCommand)
+    .build() {
 }

package/dist-es/commands/SearchCommand.js

@@ -1,47 +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 { SearchOutputFilterSensitiveLog } from "../models/models_1";
 import { de_SearchCommand, se_SearchCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class SearchCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, SearchCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "DataZoneClient";
-        const commandName = "SearchCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: SearchOutputFilterSensitiveLog,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "DataZone",
-                operation: "Search",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SearchCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SearchCommand(output, context);
-    }
+export class SearchCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("DataZone", "Search", {})
+    .n("DataZoneClient", "SearchCommand")
+    .f(void 0, SearchOutputFilterSensitiveLog)
+    .ser(se_SearchCommand)
+    .de(de_SearchCommand)
+    .build() {
 }