@aws-sdk/client-comprehend 3.278.0 → 3.281.0

package/dist-es/Comprehend.js

@@ -6,13 +6,17 @@ import { BatchDetectSyntaxCommand, } from "./commands/BatchDetectSyntaxCommand";
 import { BatchDetectTargetedSentimentCommand, } from "./commands/BatchDetectTargetedSentimentCommand";
 import { ClassifyDocumentCommand, } from "./commands/ClassifyDocumentCommand";
 import { ContainsPiiEntitiesCommand, } from "./commands/ContainsPiiEntitiesCommand";
+import { CreateDatasetCommand, } from "./commands/CreateDatasetCommand";
 import { CreateDocumentClassifierCommand, } from "./commands/CreateDocumentClassifierCommand";
 import { CreateEndpointCommand, } from "./commands/CreateEndpointCommand";
 import { CreateEntityRecognizerCommand, } from "./commands/CreateEntityRecognizerCommand";
+import { CreateFlywheelCommand, } from "./commands/CreateFlywheelCommand";
 import { DeleteDocumentClassifierCommand, } from "./commands/DeleteDocumentClassifierCommand";
 import { DeleteEndpointCommand, } from "./commands/DeleteEndpointCommand";
 import { DeleteEntityRecognizerCommand, } from "./commands/DeleteEntityRecognizerCommand";
+import { DeleteFlywheelCommand, } from "./commands/DeleteFlywheelCommand";
 import { DeleteResourcePolicyCommand, } from "./commands/DeleteResourcePolicyCommand";
+import { DescribeDatasetCommand, } from "./commands/DescribeDatasetCommand";
 import { DescribeDocumentClassificationJobCommand, } from "./commands/DescribeDocumentClassificationJobCommand";
 import { DescribeDocumentClassifierCommand, } from "./commands/DescribeDocumentClassifierCommand";
 import { DescribeDominantLanguageDetectionJobCommand, } from "./commands/DescribeDominantLanguageDetectionJobCommand";
@@ -20,6 +24,8 @@ import { DescribeEndpointCommand, } from "./commands/DescribeEndpointCommand";
 import { DescribeEntitiesDetectionJobCommand, } from "./commands/DescribeEntitiesDetectionJobCommand";
 import { DescribeEntityRecognizerCommand, } from "./commands/DescribeEntityRecognizerCommand";
 import { DescribeEventsDetectionJobCommand, } from "./commands/DescribeEventsDetectionJobCommand";
+import { DescribeFlywheelCommand, } from "./commands/DescribeFlywheelCommand";
+import { DescribeFlywheelIterationCommand, } from "./commands/DescribeFlywheelIterationCommand";
 import { DescribeKeyPhrasesDetectionJobCommand, } from "./commands/DescribeKeyPhrasesDetectionJobCommand";
 import { DescribePiiEntitiesDetectionJobCommand, } from "./commands/DescribePiiEntitiesDetectionJobCommand";
 import { DescribeResourcePolicyCommand, } from "./commands/DescribeResourcePolicyCommand";
@@ -34,6 +40,7 @@ import { DetectSentimentCommand, } from "./commands/DetectSentimentCommand";
 import { DetectSyntaxCommand, } from "./commands/DetectSyntaxCommand";
 import { DetectTargetedSentimentCommand, } from "./commands/DetectTargetedSentimentCommand";
 import { ImportModelCommand } from "./commands/ImportModelCommand";
+import { ListDatasetsCommand, } from "./commands/ListDatasetsCommand";
 import { ListDocumentClassificationJobsCommand, } from "./commands/ListDocumentClassificationJobsCommand";
 import { ListDocumentClassifiersCommand, } from "./commands/ListDocumentClassifiersCommand";
 import { ListDocumentClassifierSummariesCommand, } from "./commands/ListDocumentClassifierSummariesCommand";
@@ -43,6 +50,8 @@ import { ListEntitiesDetectionJobsCommand, } from "./commands/ListEntitiesDetect
 import { ListEntityRecognizersCommand, } from "./commands/ListEntityRecognizersCommand";
 import { ListEntityRecognizerSummariesCommand, } from "./commands/ListEntityRecognizerSummariesCommand";
 import { ListEventsDetectionJobsCommand, } from "./commands/ListEventsDetectionJobsCommand";
+import { ListFlywheelIterationHistoryCommand, } from "./commands/ListFlywheelIterationHistoryCommand";
+import { ListFlywheelsCommand, } from "./commands/ListFlywheelsCommand";
 import { ListKeyPhrasesDetectionJobsCommand, } from "./commands/ListKeyPhrasesDetectionJobsCommand";
 import { ListPiiEntitiesDetectionJobsCommand, } from "./commands/ListPiiEntitiesDetectionJobsCommand";
 import { ListSentimentDetectionJobsCommand, } from "./commands/ListSentimentDetectionJobsCommand";
@@ -54,6 +63,7 @@ import { StartDocumentClassificationJobCommand, } from "./commands/StartDocument
 import { StartDominantLanguageDetectionJobCommand, } from "./commands/StartDominantLanguageDetectionJobCommand";
 import { StartEntitiesDetectionJobCommand, } from "./commands/StartEntitiesDetectionJobCommand";
 import { StartEventsDetectionJobCommand, } from "./commands/StartEventsDetectionJobCommand";
+import { StartFlywheelIterationCommand, } from "./commands/StartFlywheelIterationCommand";
 import { StartKeyPhrasesDetectionJobCommand, } from "./commands/StartKeyPhrasesDetectionJobCommand";
 import { StartPiiEntitiesDetectionJobCommand, } from "./commands/StartPiiEntitiesDetectionJobCommand";
 import { StartSentimentDetectionJobCommand, } from "./commands/StartSentimentDetectionJobCommand";
@@ -71,6 +81,7 @@ import { StopTrainingEntityRecognizerCommand, } from "./commands/StopTrainingEnt
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateEndpointCommand, } from "./commands/UpdateEndpointCommand";
+import { UpdateFlywheelCommand, } from "./commands/UpdateFlywheelCommand";
 import { ComprehendClient } from "./ComprehendClient";
 export class Comprehend extends ComprehendClient {
     batchDetectDominantLanguage(args, optionsOrCb, cb) {
@@ -185,6 +196,20 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createDataset(args, optionsOrCb, cb) {
+        const command = new CreateDatasetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     createDocumentClassifier(args, optionsOrCb, cb) {
         const command = new CreateDocumentClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -227,6 +252,20 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createFlywheel(args, optionsOrCb, cb) {
+        const command = new CreateFlywheelCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteDocumentClassifier(args, optionsOrCb, cb) {
         const command = new DeleteDocumentClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -269,6 +308,20 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteFlywheel(args, optionsOrCb, cb) {
+        const command = new DeleteFlywheelCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteResourcePolicy(args, optionsOrCb, cb) {
         const command = new DeleteResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -283,6 +336,20 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    describeDataset(args, optionsOrCb, cb) {
+        const command = new DescribeDatasetCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     describeDocumentClassificationJob(args, optionsOrCb, cb) {
         const command = new DescribeDocumentClassificationJobCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -381,6 +448,34 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    describeFlywheel(args, optionsOrCb, cb) {
+        const command = new DescribeFlywheelCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    describeFlywheelIteration(args, optionsOrCb, cb) {
+        const command = new DescribeFlywheelIterationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     describeKeyPhrasesDetectionJob(args, optionsOrCb, cb) {
         const command = new DescribeKeyPhrasesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -577,6 +672,20 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listDatasets(args, optionsOrCb, cb) {
+        const command = new ListDatasetsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listDocumentClassificationJobs(args, optionsOrCb, cb) {
         const command = new ListDocumentClassificationJobsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -703,6 +812,34 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listFlywheelIterationHistory(args, optionsOrCb, cb) {
+        const command = new ListFlywheelIterationHistoryCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listFlywheels(args, optionsOrCb, cb) {
+        const command = new ListFlywheelsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     listKeyPhrasesDetectionJobs(args, optionsOrCb, cb) {
         const command = new ListKeyPhrasesDetectionJobsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -857,6 +994,20 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    startFlywheelIteration(args, optionsOrCb, cb) {
+        const command = new StartFlywheelIterationCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     startKeyPhrasesDetectionJob(args, optionsOrCb, cb) {
         const command = new StartKeyPhrasesDetectionJobCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -1095,4 +1246,18 @@ export class Comprehend extends ComprehendClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateFlywheel(args, optionsOrCb, cb) {
+        const command = new UpdateFlywheelCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
 }

package/dist-es/commands/CreateDatasetCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDatasetRequestFilterSensitiveLog, CreateDatasetResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1CreateDatasetCommand, serializeAws_json1_1CreateDatasetCommand, } from "../protocols/Aws_json1_1";
+export class CreateDatasetCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatasetCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "CreateDatasetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateDatasetRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateDatasetResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1CreateDatasetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1CreateDatasetCommand(output, context);
+    }
+}

package/dist-es/commands/CreateFlywheelCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateFlywheelRequestFilterSensitiveLog, CreateFlywheelResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1CreateFlywheelCommand, serializeAws_json1_1CreateFlywheelCommand, } from "../protocols/Aws_json1_1";
+export class CreateFlywheelCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateFlywheelCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "CreateFlywheelCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateFlywheelRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateFlywheelResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1CreateFlywheelCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1CreateFlywheelCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteFlywheelCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteFlywheelRequestFilterSensitiveLog, DeleteFlywheelResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1DeleteFlywheelCommand, serializeAws_json1_1DeleteFlywheelCommand, } from "../protocols/Aws_json1_1";
+export class DeleteFlywheelCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteFlywheelCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "DeleteFlywheelCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteFlywheelRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteFlywheelResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1DeleteFlywheelCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1DeleteFlywheelCommand(output, context);
+    }
+}

package/dist-es/commands/DescribeDatasetCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeDatasetRequestFilterSensitiveLog, DescribeDatasetResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1DescribeDatasetCommand, serializeAws_json1_1DescribeDatasetCommand, } from "../protocols/Aws_json1_1";
+export class DescribeDatasetCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DescribeDatasetCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "DescribeDatasetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DescribeDatasetRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DescribeDatasetResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1DescribeDatasetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1DescribeDatasetCommand(output, context);
+    }
+}

package/dist-es/commands/DescribeFlywheelCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeFlywheelRequestFilterSensitiveLog, DescribeFlywheelResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1DescribeFlywheelCommand, serializeAws_json1_1DescribeFlywheelCommand, } from "../protocols/Aws_json1_1";
+export class DescribeFlywheelCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DescribeFlywheelCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "DescribeFlywheelCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DescribeFlywheelRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DescribeFlywheelResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1DescribeFlywheelCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1DescribeFlywheelCommand(output, context);
+    }
+}

package/dist-es/commands/DescribeFlywheelIterationCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeFlywheelIterationRequestFilterSensitiveLog, DescribeFlywheelIterationResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1DescribeFlywheelIterationCommand, serializeAws_json1_1DescribeFlywheelIterationCommand, } from "../protocols/Aws_json1_1";
+export class DescribeFlywheelIterationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DescribeFlywheelIterationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "DescribeFlywheelIterationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DescribeFlywheelIterationRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DescribeFlywheelIterationResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1DescribeFlywheelIterationCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1DescribeFlywheelIterationCommand(output, context);
+    }
+}

package/dist-es/commands/ListDatasetsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListDatasetsRequestFilterSensitiveLog, ListDatasetsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListDatasetsCommand, serializeAws_json1_1ListDatasetsCommand, } from "../protocols/Aws_json1_1";
+export class ListDatasetsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListDatasetsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "ListDatasetsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListDatasetsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListDatasetsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListDatasetsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListDatasetsCommand(output, context);
+    }
+}

package/dist-es/commands/ListFlywheelIterationHistoryCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFlywheelIterationHistoryRequestFilterSensitiveLog, ListFlywheelIterationHistoryResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListFlywheelIterationHistoryCommand, serializeAws_json1_1ListFlywheelIterationHistoryCommand, } from "../protocols/Aws_json1_1";
+export class ListFlywheelIterationHistoryCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListFlywheelIterationHistoryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "ListFlywheelIterationHistoryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListFlywheelIterationHistoryRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListFlywheelIterationHistoryResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListFlywheelIterationHistoryCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListFlywheelIterationHistoryCommand(output, context);
+    }
+}

package/dist-es/commands/ListFlywheelsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListFlywheelsRequestFilterSensitiveLog, ListFlywheelsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_1ListFlywheelsCommand, serializeAws_json1_1ListFlywheelsCommand, } from "../protocols/Aws_json1_1";
+export class ListFlywheelsCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListFlywheelsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ComprehendClient";
+        const commandName = "ListFlywheelsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListFlywheelsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListFlywheelsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_1ListFlywheelsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_1ListFlywheelsCommand(output, context);
+    }
+}