@aws-sdk/client-comprehend 3.477.0 → 3.481.0

package/dist-cjs/pagination/ListFlywheelIterationHistoryPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListFlywheelIterationHistory = void 0;
+const core_1 = require("@smithy/core");
 const ListFlywheelIterationHistoryCommand_1 = require("../commands/ListFlywheelIterationHistoryCommand");
 const ComprehendClient_1 = require("../ComprehendClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListFlywheelIterationHistoryCommand_1.ListFlywheelIterationHistoryCommand(input), ...args);
-};
-async function* paginateListFlywheelIterationHistory(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof ComprehendClient_1.ComprehendClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Comprehend | ComprehendClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListFlywheelIterationHistory = paginateListFlywheelIterationHistory;
+exports.paginateListFlywheelIterationHistory = (0, core_1.createPaginator)(ComprehendClient_1.ComprehendClient, ListFlywheelIterationHistoryCommand_1.ListFlywheelIterationHistoryCommand, "NextToken", "NextToken", "MaxResults");

package/dist-cjs/pagination/ListFlywheelsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListFlywheels = void 0;
+const core_1 = require("@smithy/core");
 const ListFlywheelsCommand_1 = require("../commands/ListFlywheelsCommand");
 const ComprehendClient_1 = require("../ComprehendClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListFlywheelsCommand_1.ListFlywheelsCommand(input), ...args);
-};
-async function* paginateListFlywheels(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof ComprehendClient_1.ComprehendClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Comprehend | ComprehendClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListFlywheels = paginateListFlywheels;
+exports.paginateListFlywheels = (0, core_1.createPaginator)(ComprehendClient_1.ComprehendClient, ListFlywheelsCommand_1.ListFlywheelsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-cjs/pagination/ListKeyPhrasesDetectionJobsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListKeyPhrasesDetectionJobs = void 0;
+const core_1 = require("@smithy/core");
 const ListKeyPhrasesDetectionJobsCommand_1 = require("../commands/ListKeyPhrasesDetectionJobsCommand");
 const ComprehendClient_1 = require("../ComprehendClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListKeyPhrasesDetectionJobsCommand_1.ListKeyPhrasesDetectionJobsCommand(input), ...args);
-};
-async function* paginateListKeyPhrasesDetectionJobs(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof ComprehendClient_1.ComprehendClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Comprehend | ComprehendClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListKeyPhrasesDetectionJobs = paginateListKeyPhrasesDetectionJobs;
+exports.paginateListKeyPhrasesDetectionJobs = (0, core_1.createPaginator)(ComprehendClient_1.ComprehendClient, ListKeyPhrasesDetectionJobsCommand_1.ListKeyPhrasesDetectionJobsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-cjs/pagination/ListPiiEntitiesDetectionJobsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListPiiEntitiesDetectionJobs = void 0;
+const core_1 = require("@smithy/core");
 const ListPiiEntitiesDetectionJobsCommand_1 = require("../commands/ListPiiEntitiesDetectionJobsCommand");
 const ComprehendClient_1 = require("../ComprehendClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListPiiEntitiesDetectionJobsCommand_1.ListPiiEntitiesDetectionJobsCommand(input), ...args);
-};
-async function* paginateListPiiEntitiesDetectionJobs(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof ComprehendClient_1.ComprehendClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Comprehend | ComprehendClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListPiiEntitiesDetectionJobs = paginateListPiiEntitiesDetectionJobs;
+exports.paginateListPiiEntitiesDetectionJobs = (0, core_1.createPaginator)(ComprehendClient_1.ComprehendClient, ListPiiEntitiesDetectionJobsCommand_1.ListPiiEntitiesDetectionJobsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-cjs/pagination/ListSentimentDetectionJobsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListSentimentDetectionJobs = void 0;
+const core_1 = require("@smithy/core");
 const ListSentimentDetectionJobsCommand_1 = require("../commands/ListSentimentDetectionJobsCommand");
 const ComprehendClient_1 = require("../ComprehendClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListSentimentDetectionJobsCommand_1.ListSentimentDetectionJobsCommand(input), ...args);
-};
-async function* paginateListSentimentDetectionJobs(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof ComprehendClient_1.ComprehendClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Comprehend | ComprehendClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListSentimentDetectionJobs = paginateListSentimentDetectionJobs;
+exports.paginateListSentimentDetectionJobs = (0, core_1.createPaginator)(ComprehendClient_1.ComprehendClient, ListSentimentDetectionJobsCommand_1.ListSentimentDetectionJobsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-cjs/pagination/ListTargetedSentimentDetectionJobsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListTargetedSentimentDetectionJobs = void 0;
+const core_1 = require("@smithy/core");
 const ListTargetedSentimentDetectionJobsCommand_1 = require("../commands/ListTargetedSentimentDetectionJobsCommand");
 const ComprehendClient_1 = require("../ComprehendClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListTargetedSentimentDetectionJobsCommand_1.ListTargetedSentimentDetectionJobsCommand(input), ...args);
-};
-async function* paginateListTargetedSentimentDetectionJobs(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof ComprehendClient_1.ComprehendClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Comprehend | ComprehendClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListTargetedSentimentDetectionJobs = paginateListTargetedSentimentDetectionJobs;
+exports.paginateListTargetedSentimentDetectionJobs = (0, core_1.createPaginator)(ComprehendClient_1.ComprehendClient, ListTargetedSentimentDetectionJobsCommand_1.ListTargetedSentimentDetectionJobsCommand, "NextToken", "NextToken", "MaxResults");

package/dist-cjs/pagination/ListTopicsDetectionJobsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListTopicsDetectionJobs = void 0;
+const core_1 = require("@smithy/core");
 const ListTopicsDetectionJobsCommand_1 = require("../commands/ListTopicsDetectionJobsCommand");
 const ComprehendClient_1 = require("../ComprehendClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListTopicsDetectionJobsCommand_1.ListTopicsDetectionJobsCommand(input), ...args);
-};
-async function* paginateListTopicsDetectionJobs(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.NextToken = token;
-        input["MaxResults"] = config.pageSize;
-        if (config.client instanceof ComprehendClient_1.ComprehendClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected Comprehend | ComprehendClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.NextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListTopicsDetectionJobs = paginateListTopicsDetectionJobs;
+exports.paginateListTopicsDetectionJobs = (0, core_1.createPaginator)(ComprehendClient_1.ComprehendClient, ListTopicsDetectionJobsCommand_1.ListTopicsDetectionJobsCommand, "NextToken", "NextToken", "MaxResults");

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

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

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

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

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

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