@aws-sdk/client-omics 3.489.0 → 3.495.0

package/dist-cjs/waiters/waitForReferenceImportJobCompleted.js

@@ -1,90 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilReferenceImportJobCompleted = exports.waitForReferenceImportJobCompleted = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetReferenceImportJobCommand_1 = require("../commands/GetReferenceImportJobCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetReferenceImportJobCommand_1.GetReferenceImportJobCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "COMPLETED") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "SUBMITTED") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "IN_PROGRESS") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "CANCELLING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "CANCELLED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "COMPLETED_WITH_FAILURES") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForReferenceImportJobCompleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForReferenceImportJobCompleted = waitForReferenceImportJobCompleted;
-const waitUntilReferenceImportJobCompleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilReferenceImportJobCompleted = waitUntilReferenceImportJobCompleted;
+module.exports = require("../index.js");

package/dist-cjs/waiters/waitForRunCompleted.js

@@ -1,81 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilRunCompleted = exports.waitForRunCompleted = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetRunCommand_1 = require("../commands/GetRunCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetRunCommand_1.GetRunCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "COMPLETED") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "PENDING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "STARTING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "RUNNING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "STOPPING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForRunCompleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForRunCompleted = waitForRunCompleted;
-const waitUntilRunCompleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilRunCompleted = waitUntilRunCompleted;
+module.exports = require("../index.js");

package/dist-cjs/waiters/waitForRunRunning.js

@@ -1,72 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilRunRunning = exports.waitForRunRunning = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetRunCommand_1 = require("../commands/GetRunCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetRunCommand_1.GetRunCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "RUNNING") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "PENDING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "STARTING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "CANCELLED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForRunRunning = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForRunRunning = waitForRunRunning;
-const waitUntilRunRunning = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilRunRunning = waitUntilRunRunning;
+module.exports = require("../index.js");

package/dist-cjs/waiters/waitForTaskCompleted.js

@@ -1,81 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilTaskCompleted = exports.waitForTaskCompleted = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetRunTaskCommand_1 = require("../commands/GetRunTaskCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetRunTaskCommand_1.GetRunTaskCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "COMPLETED") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "PENDING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "STARTING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "RUNNING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "STOPPING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForTaskCompleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForTaskCompleted = waitForTaskCompleted;
-const waitUntilTaskCompleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilTaskCompleted = waitUntilTaskCompleted;
+module.exports = require("../index.js");

package/dist-cjs/waiters/waitForTaskRunning.js

@@ -1,72 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilTaskRunning = exports.waitForTaskRunning = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetRunTaskCommand_1 = require("../commands/GetRunTaskCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetRunTaskCommand_1.GetRunTaskCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "RUNNING") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "PENDING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "STARTING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "CANCELLED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForTaskRunning = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForTaskRunning = waitForTaskRunning;
-const waitUntilTaskRunning = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilTaskRunning = waitUntilTaskRunning;
+module.exports = require("../index.js");

package/dist-cjs/waiters/waitForVariantImportJobCreated.js

@@ -1,72 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilVariantImportJobCreated = exports.waitForVariantImportJobCreated = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetVariantImportJobCommand_1 = require("../commands/GetVariantImportJobCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetVariantImportJobCommand_1.GetVariantImportJobCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "SUBMITTED") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "IN_PROGRESS") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "CANCELLED") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "COMPLETED") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForVariantImportJobCreated = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForVariantImportJobCreated = waitForVariantImportJobCreated;
-const waitUntilVariantImportJobCreated = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilVariantImportJobCreated = waitUntilVariantImportJobCreated;
+module.exports = require("../index.js");

package/dist-cjs/waiters/waitForVariantStoreCreated.js

@@ -1,63 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilVariantStoreCreated = exports.waitForVariantStoreCreated = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetVariantStoreCommand_1 = require("../commands/GetVariantStoreCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetVariantStoreCommand_1.GetVariantStoreCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "ACTIVE") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "CREATING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "UPDATING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForVariantStoreCreated = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForVariantStoreCreated = waitForVariantStoreCreated;
-const waitUntilVariantStoreCreated = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilVariantStoreCreated = waitUntilVariantStoreCreated;
+module.exports = require("../index.js");

package/dist-cjs/waiters/waitForVariantStoreDeleted.js

@@ -1,48 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilVariantStoreDeleted = exports.waitForVariantStoreDeleted = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetVariantStoreCommand_1 = require("../commands/GetVariantStoreCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetVariantStoreCommand_1.GetVariantStoreCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "DELETED") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "DELETING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-        if (exception.name && exception.name == "ResourceNotFoundException") {
-            return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-        }
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForVariantStoreDeleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForVariantStoreDeleted = waitForVariantStoreDeleted;
-const waitUntilVariantStoreDeleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 600 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilVariantStoreDeleted = waitUntilVariantStoreDeleted;
+module.exports = require("../index.js");

package/dist-cjs/waiters/waitForWorkflowActive.js

@@ -1,63 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitUntilWorkflowActive = exports.waitForWorkflowActive = void 0;
-const util_waiter_1 = require("@smithy/util-waiter");
-const GetWorkflowCommand_1 = require("../commands/GetWorkflowCommand");
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new GetWorkflowCommand_1.GetWorkflowCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "ACTIVE") {
-                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "CREATING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "UPDATING") {
-                return { state: util_waiter_1.WaiterState.RETRY, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: util_waiter_1.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: util_waiter_1.WaiterState.RETRY, reason };
-};
-const waitForWorkflowActive = async (params, input) => {
-    const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-};
-exports.waitForWorkflowActive = waitForWorkflowActive;
-const waitUntilWorkflowActive = async (params, input) => {
-    const serviceDefaults = { minDelay: 3, maxDelay: 30 };
-    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-    return (0, util_waiter_1.checkExceptions)(result);
-};
-exports.waitUntilWorkflowActive = waitUntilWorkflowActive;
+module.exports = require("../index.js");