Add/update filtered-sum-bms benchmark

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/index.js

@@ -0,0 +1,36 @@
+export * from "./waitForBundleTaskComplete";
+export * from "./waitForConversionTaskCancelled";
+export * from "./waitForConversionTaskCompleted";
+export * from "./waitForConversionTaskDeleted";
+export * from "./waitForCustomerGatewayAvailable";
+export * from "./waitForExportTaskCancelled";
+export * from "./waitForExportTaskCompleted";
+export * from "./waitForImageAvailable";
+export * from "./waitForImageExists";
+export * from "./waitForInstanceExists";
+export * from "./waitForInstanceRunning";
+export * from "./waitForInstanceStatusOk";
+export * from "./waitForInstanceStopped";
+export * from "./waitForInstanceTerminated";
+export * from "./waitForInternetGatewayExists";
+export * from "./waitForKeyPairExists";
+export * from "./waitForNatGatewayAvailable";
+export * from "./waitForNatGatewayDeleted";
+export * from "./waitForNetworkInterfaceAvailable";
+export * from "./waitForSnapshotImported";
+export * from "./waitForSecurityGroupExists";
+export * from "./waitForSnapshotCompleted";
+export * from "./waitForSpotInstanceRequestFulfilled";
+export * from "./waitForStoreImageTaskComplete";
+export * from "./waitForSubnetAvailable";
+export * from "./waitForSystemStatusOk";
+export * from "./waitForPasswordDataAvailable";
+export * from "./waitForVolumeAvailable";
+export * from "./waitForVolumeDeleted";
+export * from "./waitForVolumeInUse";
+export * from "./waitForVpcAvailable";
+export * from "./waitForVpcExists";
+export * from "./waitForVpcPeeringConnectionDeleted";
+export * from "./waitForVpcPeeringConnectionExists";
+export * from "./waitForVpnConnectionAvailable";
+export * from "./waitForVpnConnectionDeleted";

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForBundleTaskComplete.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeBundleTasksCommand } from "../commands/DescribeBundleTasksCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeBundleTasksCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.BundleTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "complete";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.BundleTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "failed") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForBundleTaskComplete = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilBundleTaskComplete = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForConversionTaskCancelled.js

@@ -0,0 +1,39 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeConversionTasksCommand, } from "../commands/DescribeConversionTasksCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeConversionTasksCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ConversionTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "cancelled";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForConversionTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilConversionTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForConversionTaskCompleted.js

@@ -0,0 +1,69 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeConversionTasksCommand, } from "../commands/DescribeConversionTasksCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeConversionTasksCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ConversionTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "completed";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ConversionTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "cancelled") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ConversionTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "cancelling") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForConversionTaskCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilConversionTaskCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForConversionTaskDeleted.js

@@ -0,0 +1,39 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeConversionTasksCommand, } from "../commands/DescribeConversionTasksCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeConversionTasksCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ConversionTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "deleted";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForConversionTaskDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilConversionTaskDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForCustomerGatewayAvailable.js

@@ -0,0 +1,69 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeCustomerGatewaysCommand, } from "../commands/DescribeCustomerGatewaysCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeCustomerGatewaysCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.CustomerGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "available";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.CustomerGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "deleted") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.CustomerGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "deleting") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForCustomerGatewayAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilCustomerGatewayAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForExportTaskCancelled.js

@@ -0,0 +1,39 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeExportTasksCommand } from "../commands/DescribeExportTasksCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeExportTasksCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ExportTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "cancelled";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForExportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilExportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForExportTaskCompleted.js

@@ -0,0 +1,39 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeExportTasksCommand } from "../commands/DescribeExportTasksCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeExportTasksCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ExportTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "completed";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForExportTaskCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilExportTaskCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForImageAvailable.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeImagesCommand } from "../commands/DescribeImagesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeImagesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Images);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "available";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Images);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "failed") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForImageAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilImageAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForImageExists.js

@@ -0,0 +1,35 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeImagesCommand } from "../commands/DescribeImagesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeImagesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Images);
+                return flat_1.length > 0.0;
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidAMIID.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForImageExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilImageExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForInstanceExists.js

@@ -0,0 +1,35 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeInstancesCommand } from "../commands/DescribeInstancesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeInstancesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                return flat_1.length > 0.0;
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidInstanceID.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInstanceExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInstanceExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForInstanceRunning.js

@@ -0,0 +1,103 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeInstancesCommand } from "../commands/DescribeInstancesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeInstancesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            let allStringEq_8 = returnComparator().length > 0;
+            for (const element_7 of returnComparator()) {
+                allStringEq_8 = allStringEq_8 && element_7 == "running";
+            }
+            if (allStringEq_8) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            for (const anyStringEq_7 of returnComparator()) {
+                if (anyStringEq_7 == "shutting-down") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            for (const anyStringEq_7 of returnComparator()) {
+                if (anyStringEq_7 == "terminated") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            for (const anyStringEq_7 of returnComparator()) {
+                if (anyStringEq_7 == "stopping") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidInstanceID.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInstanceRunning = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInstanceRunning = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForInstanceStatusOk.js

@@ -0,0 +1,42 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeInstanceStatusCommand, } from "../commands/DescribeInstanceStatusCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeInstanceStatusCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.InstanceStatuses);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.InstanceStatus.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "ok";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidInstanceID.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInstanceStatusOk = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInstanceStatusOk = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForInstanceStopped.js

@@ -0,0 +1,81 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeInstancesCommand } from "../commands/DescribeInstancesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeInstancesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            let allStringEq_8 = returnComparator().length > 0;
+            for (const element_7 of returnComparator()) {
+                allStringEq_8 = allStringEq_8 && element_7 == "stopped";
+            }
+            if (allStringEq_8) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            for (const anyStringEq_7 of returnComparator()) {
+                if (anyStringEq_7 == "pending") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            for (const anyStringEq_7 of returnComparator()) {
+                if (anyStringEq_7 == "terminated") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInstanceStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInstanceStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForInstanceTerminated.js

@@ -0,0 +1,81 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeInstancesCommand } from "../commands/DescribeInstancesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeInstancesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            let allStringEq_8 = returnComparator().length > 0;
+            for (const element_7 of returnComparator()) {
+                allStringEq_8 = allStringEq_8 && element_7 == "terminated";
+            }
+            if (allStringEq_8) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            for (const anyStringEq_7 of returnComparator()) {
+                if (anyStringEq_7 == "pending") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Reservations);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Instances;
+                });
+                const flat_4 = [].concat(...projection_3);
+                const projection_6 = flat_4.map((element_5) => {
+                    return element_5.State.Name;
+                });
+                return projection_6;
+            };
+            for (const anyStringEq_7 of returnComparator()) {
+                if (anyStringEq_7 == "stopping") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInstanceTerminated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInstanceTerminated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForInternetGatewayExists.js

@@ -0,0 +1,38 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeInternetGatewaysCommand, } from "../commands/DescribeInternetGatewaysCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeInternetGatewaysCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.InternetGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.InternetGatewayId;
+                });
+                return projection_3.length > 0.0;
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidInternetGateway.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInternetGatewayExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInternetGatewayExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForKeyPairExists.js

@@ -0,0 +1,38 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeKeyPairsCommand } from "../commands/DescribeKeyPairsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeKeyPairsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.KeyPairs);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.KeyName;
+                });
+                return projection_3.length > 0.0;
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidKeyPair.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForKeyPairExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilKeyPairExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForNatGatewayAvailable.js

@@ -0,0 +1,87 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeNatGatewaysCommand } from "../commands/DescribeNatGatewaysCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeNatGatewaysCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.NatGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "available";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.NatGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "failed") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.NatGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "deleting") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.NatGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "deleted") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "NatGatewayNotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForNatGatewayAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilNatGatewayAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForNatGatewayDeleted.js

@@ -0,0 +1,42 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeNatGatewaysCommand } from "../commands/DescribeNatGatewaysCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeNatGatewaysCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.NatGateways);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "deleted";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "NatGatewayNotFound") {
+            return { state: WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForNatGatewayDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilNatGatewayDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForNetworkInterfaceAvailable.js

@@ -0,0 +1,42 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeNetworkInterfacesCommand, } from "../commands/DescribeNetworkInterfacesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeNetworkInterfacesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.NetworkInterfaces);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "available";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidNetworkInterfaceID.NotFound") {
+            return { state: WaiterState.FAILURE, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForNetworkInterfaceAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilNetworkInterfaceAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForPasswordDataAvailable.js

@@ -0,0 +1,31 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetPasswordDataCommand } from "../commands/GetPasswordDataCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetPasswordDataCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.PasswordData.length > 0.0;
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForPasswordDataAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilPasswordDataAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForSecurityGroupExists.js

@@ -0,0 +1,38 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeSecurityGroupsCommand, } from "../commands/DescribeSecurityGroupsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeSecurityGroupsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SecurityGroups);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.GroupId;
+                });
+                return projection_3.length > 0.0;
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidGroup.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForSecurityGroupExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilSecurityGroupExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForSnapshotCompleted.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeSnapshotsCommand } from "../commands/DescribeSnapshotsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeSnapshotsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Snapshots);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "completed";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Snapshots);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "error") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForSnapshotCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilSnapshotCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForSnapshotImported.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeImportSnapshotTasksCommand, } from "../commands/DescribeImportSnapshotTasksCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeImportSnapshotTasksCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ImportSnapshotTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.SnapshotTaskDetail.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "completed";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.ImportSnapshotTasks);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.SnapshotTaskDetail.Status;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "error") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForSnapshotImported = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilSnapshotImported = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForSpotInstanceRequestFulfilled.js

@@ -0,0 +1,119 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeSpotInstanceRequestsCommand, } from "../commands/DescribeSpotInstanceRequestsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeSpotInstanceRequestsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SpotInstanceRequests);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status.Code;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "fulfilled";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SpotInstanceRequests);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status.Code;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "request-canceled-and-instance-running";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SpotInstanceRequests);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status.Code;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "schedule-expired") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SpotInstanceRequests);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status.Code;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "canceled-before-fulfillment") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SpotInstanceRequests);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status.Code;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "bad-parameters") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.SpotInstanceRequests);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status.Code;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "system-error") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidSpotInstanceRequestID.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForSpotInstanceRequestFulfilled = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilSpotInstanceRequestFulfilled = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForStoreImageTaskComplete.js

@@ -0,0 +1,69 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeStoreImageTasksCommand, } from "../commands/DescribeStoreImageTasksCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeStoreImageTasksCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.StoreImageTaskResults);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.StoreTaskState;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "Completed";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.StoreImageTaskResults);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.StoreTaskState;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "Failed") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.StoreImageTaskResults);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.StoreTaskState;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "InProgress") {
+                    return { state: WaiterState.RETRY, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForStoreImageTaskComplete = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilStoreImageTaskComplete = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForSubnetAvailable.js

@@ -0,0 +1,39 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeSubnetsCommand } from "../commands/DescribeSubnetsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeSubnetsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Subnets);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "available";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForSubnetAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilSubnetAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForSystemStatusOk.js

@@ -0,0 +1,39 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeInstanceStatusCommand, } from "../commands/DescribeInstanceStatusCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeInstanceStatusCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.InstanceStatuses);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.SystemStatus.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "ok";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForSystemStatusOk = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilSystemStatusOk = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVolumeAvailable.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVolumesCommand } from "../commands/DescribeVolumesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVolumesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Volumes);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "available";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Volumes);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "deleted") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVolumeAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVolumeAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVolumeDeleted.js

@@ -0,0 +1,42 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVolumesCommand } from "../commands/DescribeVolumesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVolumesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Volumes);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "deleted";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidVolume.NotFound") {
+            return { state: WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVolumeDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVolumeDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVolumeInUse.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVolumesCommand } from "../commands/DescribeVolumesCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVolumesCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Volumes);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "in-use";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Volumes);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "deleted") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVolumeInUse = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVolumeInUse = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVpcAvailable.js

@@ -0,0 +1,39 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVpcsCommand } from "../commands/DescribeVpcsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVpcsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.Vpcs);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "available";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVpcAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVpcAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVpcExists.js

@@ -0,0 +1,26 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVpcsCommand } from "../commands/DescribeVpcsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVpcsCommand(input));
+        reason = result;
+        return { state: WaiterState.SUCCESS, reason };
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidVpcID.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVpcExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVpcExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVpcPeeringConnectionDeleted.js

@@ -0,0 +1,42 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVpcPeeringConnectionsCommand, } from "../commands/DescribeVpcPeeringConnectionsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVpcPeeringConnectionsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.VpcPeeringConnections);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status.Code;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "deleted";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidVpcPeeringConnectionID.NotFound") {
+            return { state: WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVpcPeeringConnectionDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVpcPeeringConnectionDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVpcPeeringConnectionExists.js

@@ -0,0 +1,26 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVpcPeeringConnectionsCommand, } from "../commands/DescribeVpcPeeringConnectionsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVpcPeeringConnectionsCommand(input));
+        reason = result;
+        return { state: WaiterState.SUCCESS, reason };
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InvalidVpcPeeringConnectionID.NotFound") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVpcPeeringConnectionExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVpcPeeringConnectionExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVpnConnectionAvailable.js

@@ -0,0 +1,69 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVpnConnectionsCommand, } from "../commands/DescribeVpnConnectionsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVpnConnectionsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.VpnConnections);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "available";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.VpnConnections);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "deleting") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.VpnConnections);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "deleted") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVpnConnectionAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVpnConnectionAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

spot-launcher/node_modules/@aws-sdk/client-ec2/dist-es/waiters/waitForVpnConnectionDeleted.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeVpnConnectionsCommand, } from "../commands/DescribeVpnConnectionsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeVpnConnectionsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.VpnConnections);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = returnComparator().length > 0;
+            for (const element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && element_4 == "deleted";
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                const flat_1 = [].concat(...result.VpnConnections);
+                const projection_3 = flat_1.map((element_2) => {
+                    return element_2.State;
+                });
+                return projection_3;
+            };
+            for (const anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "pending") {
+                    return { state: WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVpnConnectionDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVpnConnectionDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};