@aws-sdk/client-omics 3.220.0

package/dist-es/commands/ListReferencesCommand.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 { ListReferencesRequestFilterSensitiveLog, ListReferencesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListReferencesCommand, serializeAws_restJson1ListReferencesCommand, } from "../protocols/Aws_restJson1";
+export class ListReferencesCommand 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, ListReferencesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListReferencesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListReferencesRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListReferencesResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListReferencesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListReferencesCommand(output, context);
+    }
+}

package/dist-es/commands/ListRunGroupsCommand.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 { ListRunGroupsRequestFilterSensitiveLog, ListRunGroupsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListRunGroupsCommand, serializeAws_restJson1ListRunGroupsCommand, } from "../protocols/Aws_restJson1";
+export class ListRunGroupsCommand 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, ListRunGroupsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListRunGroupsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListRunGroupsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListRunGroupsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListRunGroupsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListRunGroupsCommand(output, context);
+    }
+}

package/dist-es/commands/ListRunTasksCommand.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 { ListRunTasksRequestFilterSensitiveLog, ListRunTasksResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListRunTasksCommand, serializeAws_restJson1ListRunTasksCommand, } from "../protocols/Aws_restJson1";
+export class ListRunTasksCommand 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, ListRunTasksCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListRunTasksCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListRunTasksRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListRunTasksResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListRunTasksCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListRunTasksCommand(output, context);
+    }
+}

package/dist-es/commands/ListRunsCommand.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 { ListRunsRequestFilterSensitiveLog, ListRunsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListRunsCommand, serializeAws_restJson1ListRunsCommand, } from "../protocols/Aws_restJson1";
+export class ListRunsCommand 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, ListRunsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListRunsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListRunsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListRunsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListRunsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListRunsCommand(output, context);
+    }
+}

package/dist-es/commands/ListSequenceStoresCommand.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 { ListSequenceStoresRequestFilterSensitiveLog, ListSequenceStoresResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListSequenceStoresCommand, serializeAws_restJson1ListSequenceStoresCommand, } from "../protocols/Aws_restJson1";
+export class ListSequenceStoresCommand 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, ListSequenceStoresCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListSequenceStoresCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListSequenceStoresRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListSequenceStoresResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListSequenceStoresCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListSequenceStoresCommand(output, context);
+    }
+}

package/dist-es/commands/ListTagsForResourceCommand.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 { ListTagsForResourceRequestFilterSensitiveLog, ListTagsForResourceResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListTagsForResourceCommand, serializeAws_restJson1ListTagsForResourceCommand, } from "../protocols/Aws_restJson1";
+export class ListTagsForResourceCommand 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, ListTagsForResourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListTagsForResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListTagsForResourceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListTagsForResourceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListTagsForResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListTagsForResourceCommand(output, context);
+    }
+}

package/dist-es/commands/ListVariantImportJobsCommand.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 { ListVariantImportJobsRequestFilterSensitiveLog, ListVariantImportJobsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListVariantImportJobsCommand, serializeAws_restJson1ListVariantImportJobsCommand, } from "../protocols/Aws_restJson1";
+export class ListVariantImportJobsCommand 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, ListVariantImportJobsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListVariantImportJobsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListVariantImportJobsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListVariantImportJobsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListVariantImportJobsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListVariantImportJobsCommand(output, context);
+    }
+}

package/dist-es/commands/ListVariantStoresCommand.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 { ListVariantStoresRequestFilterSensitiveLog, ListVariantStoresResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListVariantStoresCommand, serializeAws_restJson1ListVariantStoresCommand, } from "../protocols/Aws_restJson1";
+export class ListVariantStoresCommand 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, ListVariantStoresCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListVariantStoresCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListVariantStoresRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListVariantStoresResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListVariantStoresCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListVariantStoresCommand(output, context);
+    }
+}

package/dist-es/commands/ListWorkflowsCommand.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 { ListWorkflowsRequestFilterSensitiveLog, ListWorkflowsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListWorkflowsCommand, serializeAws_restJson1ListWorkflowsCommand, } from "../protocols/Aws_restJson1";
+export class ListWorkflowsCommand 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, ListWorkflowsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "ListWorkflowsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListWorkflowsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListWorkflowsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListWorkflowsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListWorkflowsCommand(output, context);
+    }
+}

package/dist-es/commands/StartAnnotationImportJobCommand.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 { StartAnnotationImportRequestFilterSensitiveLog, StartAnnotationImportResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartAnnotationImportJobCommand, serializeAws_restJson1StartAnnotationImportJobCommand, } from "../protocols/Aws_restJson1";
+export class StartAnnotationImportJobCommand 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, StartAnnotationImportJobCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "StartAnnotationImportJobCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartAnnotationImportRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartAnnotationImportResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartAnnotationImportJobCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartAnnotationImportJobCommand(output, context);
+    }
+}

package/dist-es/commands/StartReadSetActivationJobCommand.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 { StartReadSetActivationJobRequestFilterSensitiveLog, StartReadSetActivationJobResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartReadSetActivationJobCommand, serializeAws_restJson1StartReadSetActivationJobCommand, } from "../protocols/Aws_restJson1";
+export class StartReadSetActivationJobCommand 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, StartReadSetActivationJobCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "StartReadSetActivationJobCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartReadSetActivationJobRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartReadSetActivationJobResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartReadSetActivationJobCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartReadSetActivationJobCommand(output, context);
+    }
+}

package/dist-es/commands/StartReadSetExportJobCommand.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 { StartReadSetExportJobRequestFilterSensitiveLog, StartReadSetExportJobResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartReadSetExportJobCommand, serializeAws_restJson1StartReadSetExportJobCommand, } from "../protocols/Aws_restJson1";
+export class StartReadSetExportJobCommand 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, StartReadSetExportJobCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "StartReadSetExportJobCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartReadSetExportJobRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartReadSetExportJobResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartReadSetExportJobCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartReadSetExportJobCommand(output, context);
+    }
+}

package/dist-es/commands/StartReadSetImportJobCommand.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 { StartReadSetImportJobRequestFilterSensitiveLog, StartReadSetImportJobResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartReadSetImportJobCommand, serializeAws_restJson1StartReadSetImportJobCommand, } from "../protocols/Aws_restJson1";
+export class StartReadSetImportJobCommand 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, StartReadSetImportJobCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "StartReadSetImportJobCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartReadSetImportJobRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartReadSetImportJobResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartReadSetImportJobCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartReadSetImportJobCommand(output, context);
+    }
+}

package/dist-es/commands/StartReferenceImportJobCommand.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 { StartReferenceImportJobRequestFilterSensitiveLog, StartReferenceImportJobResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartReferenceImportJobCommand, serializeAws_restJson1StartReferenceImportJobCommand, } from "../protocols/Aws_restJson1";
+export class StartReferenceImportJobCommand 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, StartReferenceImportJobCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "StartReferenceImportJobCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartReferenceImportJobRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartReferenceImportJobResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartReferenceImportJobCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartReferenceImportJobCommand(output, context);
+    }
+}

package/dist-es/commands/StartRunCommand.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 { StartRunRequestFilterSensitiveLog, StartRunResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1StartRunCommand, serializeAws_restJson1StartRunCommand, } from "../protocols/Aws_restJson1";
+export class StartRunCommand 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, StartRunCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OmicsClient";
+        const commandName = "StartRunCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: StartRunRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: StartRunResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1StartRunCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1StartRunCommand(output, context);
+    }
+}