@aws-sdk/client-omics 3.220.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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