@aws-sdk/client-database-migration-service 3.1046.0 → 3.1047.0

package/dist-cjs/index.js

@@ -1624,7 +1624,7 @@ const paginateDescribeSchemas = core.createPaginator(DatabaseMigrationServiceCli
 
 const paginateDescribeTableStatistics = core.createPaginator(DatabaseMigrationServiceClient, DescribeTableStatisticsCommand, "Marker", "Marker", "MaxRecords");
 
-const checkState$7 = async (client$1, input) => {
+const checkState$g = async (client$1, input) => {
     let reason;
     try {
         let result = await client$1.send(new DescribeEndpointsCommand(input));
@@ -1670,10 +1670,487 @@ const checkState$7 = async (client$1, input) => {
 };
 const waitForEndpointDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
 };
 const waitUntilEndpointDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$g);
+    return client.checkExceptions(result);
+};
+
+const checkState$f = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeExtensionPackAssociationsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForExtensionPackAssociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
+};
+const waitUntilExtensionPackAssociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$f);
+    return client.checkExceptions(result);
+};
+
+const checkState$e = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeMetadataModelAssessmentsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForMetadataModelAssessed = async (params, input) => {
+    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+};
+const waitUntilMetadataModelAssessed = async (params, input) => {
+    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$e);
+    return client.checkExceptions(result);
+};
+
+const checkState$d = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeMetadataModelConversionsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "CANCELED");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForMetadataModelConversionCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+};
+const waitUntilMetadataModelConversionCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$d);
+    return client.checkExceptions(result);
+};
+
+const checkState$c = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeMetadataModelConversionsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForMetadataModelConverted = async (params, input) => {
+    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
+};
+const waitUntilMetadataModelConverted = async (params, input) => {
+    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$c);
+    return client.checkExceptions(result);
+};
+
+const checkState$b = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeMetadataModelCreationsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForMetadataModelCreated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
+};
+const waitUntilMetadataModelCreated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$b);
+    return client.checkExceptions(result);
+};
+
+const checkState$a = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeMetadataModelCreationsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "CANCELED");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForMetadataModelCreationCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+};
+const waitUntilMetadataModelCreationCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
+    return client.checkExceptions(result);
+};
+
+const checkState$9 = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeMetadataModelExportsAsScriptCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForMetadataModelExportedAsScript = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+};
+const waitUntilMetadataModelExportedAsScript = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return client.checkExceptions(result);
+};
+
+const checkState$8 = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeMetadataModelExportsToTargetCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForMetadataModelExportedToTarget = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+};
+const waitUntilMetadataModelExportedToTarget = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return client.checkExceptions(result);
+};
+
+const checkState$7 = async (client$1, input) => {
+    let reason;
+    try {
+        let result = await client$1.send(new DescribeMetadataModelImportsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: client.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let anyStringEq_4 of returnComparator()) {
+                if (anyStringEq_4 == "FAILED") {
+                    return { state: client.WaiterState.FAILURE, reason };
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: client.WaiterState.RETRY, reason };
+};
+const waitForMetadataModelImported = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+};
+const waitUntilMetadataModelImported = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
     const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
     return client.checkExceptions(result);
 };
@@ -2594,6 +3071,15 @@ const paginators = {
 const waiters = {
     waitUntilTestConnectionSucceeds,
     waitUntilEndpointDeleted,
+    waitUntilExtensionPackAssociated,
+    waitUntilMetadataModelAssessed,
+    waitUntilMetadataModelConversionCancelled,
+    waitUntilMetadataModelConverted,
+    waitUntilMetadataModelCreated,
+    waitUntilMetadataModelCreationCancelled,
+    waitUntilMetadataModelExportedAsScript,
+    waitUntilMetadataModelExportedToTarget,
+    waitUntilMetadataModelImported,
     waitUntilReplicationInstanceAvailable,
     waitUntilReplicationInstanceDeleted,
     waitUntilReplicationTaskDeleted,
@@ -3019,6 +3505,15 @@ exports.paginateDescribeReplications = paginateDescribeReplications;
 exports.paginateDescribeSchemas = paginateDescribeSchemas;
 exports.paginateDescribeTableStatistics = paginateDescribeTableStatistics;
 exports.waitForEndpointDeleted = waitForEndpointDeleted;
+exports.waitForExtensionPackAssociated = waitForExtensionPackAssociated;
+exports.waitForMetadataModelAssessed = waitForMetadataModelAssessed;
+exports.waitForMetadataModelConversionCancelled = waitForMetadataModelConversionCancelled;
+exports.waitForMetadataModelConverted = waitForMetadataModelConverted;
+exports.waitForMetadataModelCreated = waitForMetadataModelCreated;
+exports.waitForMetadataModelCreationCancelled = waitForMetadataModelCreationCancelled;
+exports.waitForMetadataModelExportedAsScript = waitForMetadataModelExportedAsScript;
+exports.waitForMetadataModelExportedToTarget = waitForMetadataModelExportedToTarget;
+exports.waitForMetadataModelImported = waitForMetadataModelImported;
 exports.waitForReplicationInstanceAvailable = waitForReplicationInstanceAvailable;
 exports.waitForReplicationInstanceDeleted = waitForReplicationInstanceDeleted;
 exports.waitForReplicationTaskDeleted = waitForReplicationTaskDeleted;
@@ -3027,6 +3522,15 @@ exports.waitForReplicationTaskRunning = waitForReplicationTaskRunning;
 exports.waitForReplicationTaskStopped = waitForReplicationTaskStopped;
 exports.waitForTestConnectionSucceeds = waitForTestConnectionSucceeds;
 exports.waitUntilEndpointDeleted = waitUntilEndpointDeleted;
+exports.waitUntilExtensionPackAssociated = waitUntilExtensionPackAssociated;
+exports.waitUntilMetadataModelAssessed = waitUntilMetadataModelAssessed;
+exports.waitUntilMetadataModelConversionCancelled = waitUntilMetadataModelConversionCancelled;
+exports.waitUntilMetadataModelConverted = waitUntilMetadataModelConverted;
+exports.waitUntilMetadataModelCreated = waitUntilMetadataModelCreated;
+exports.waitUntilMetadataModelCreationCancelled = waitUntilMetadataModelCreationCancelled;
+exports.waitUntilMetadataModelExportedAsScript = waitUntilMetadataModelExportedAsScript;
+exports.waitUntilMetadataModelExportedToTarget = waitUntilMetadataModelExportedToTarget;
+exports.waitUntilMetadataModelImported = waitUntilMetadataModelImported;
 exports.waitUntilReplicationInstanceAvailable = waitUntilReplicationInstanceAvailable;
 exports.waitUntilReplicationInstanceDeleted = waitUntilReplicationInstanceDeleted;
 exports.waitUntilReplicationTaskDeleted = waitUntilReplicationTaskDeleted;

package/dist-es/DatabaseMigrationService.js

@@ -162,6 +162,15 @@ import { paginateDescribeReplicationTasks } from "./pagination/DescribeReplicati
 import { paginateDescribeSchemas } from "./pagination/DescribeSchemasPaginator";
 import { paginateDescribeTableStatistics } from "./pagination/DescribeTableStatisticsPaginator";
 import { waitUntilEndpointDeleted } from "./waiters/waitForEndpointDeleted";
+import { waitUntilExtensionPackAssociated } from "./waiters/waitForExtensionPackAssociated";
+import { waitUntilMetadataModelAssessed } from "./waiters/waitForMetadataModelAssessed";
+import { waitUntilMetadataModelConversionCancelled } from "./waiters/waitForMetadataModelConversionCancelled";
+import { waitUntilMetadataModelConverted } from "./waiters/waitForMetadataModelConverted";
+import { waitUntilMetadataModelCreated } from "./waiters/waitForMetadataModelCreated";
+import { waitUntilMetadataModelCreationCancelled } from "./waiters/waitForMetadataModelCreationCancelled";
+import { waitUntilMetadataModelExportedAsScript } from "./waiters/waitForMetadataModelExportedAsScript";
+import { waitUntilMetadataModelExportedToTarget } from "./waiters/waitForMetadataModelExportedToTarget";
+import { waitUntilMetadataModelImported } from "./waiters/waitForMetadataModelImported";
 import { waitUntilReplicationInstanceAvailable } from "./waiters/waitForReplicationInstanceAvailable";
 import { waitUntilReplicationInstanceDeleted } from "./waiters/waitForReplicationInstanceDeleted";
 import { waitUntilReplicationTaskDeleted } from "./waiters/waitForReplicationTaskDeleted";
@@ -337,6 +346,15 @@ const paginators = {
 const waiters = {
     waitUntilTestConnectionSucceeds,
     waitUntilEndpointDeleted,
+    waitUntilExtensionPackAssociated,
+    waitUntilMetadataModelAssessed,
+    waitUntilMetadataModelConversionCancelled,
+    waitUntilMetadataModelConverted,
+    waitUntilMetadataModelCreated,
+    waitUntilMetadataModelCreationCancelled,
+    waitUntilMetadataModelExportedAsScript,
+    waitUntilMetadataModelExportedToTarget,
+    waitUntilMetadataModelImported,
     waitUntilReplicationInstanceAvailable,
     waitUntilReplicationInstanceDeleted,
     waitUntilReplicationTaskDeleted,

package/dist-es/waiters/index.js

@@ -1,5 +1,14 @@
 export * from "./waitForTestConnectionSucceeds";
 export * from "./waitForEndpointDeleted";
+export * from "./waitForExtensionPackAssociated";
+export * from "./waitForMetadataModelAssessed";
+export * from "./waitForMetadataModelConversionCancelled";
+export * from "./waitForMetadataModelConverted";
+export * from "./waitForMetadataModelCreated";
+export * from "./waitForMetadataModelCreationCancelled";
+export * from "./waitForMetadataModelExportedAsScript";
+export * from "./waitForMetadataModelExportedToTarget";
+export * from "./waitForMetadataModelImported";
 export * from "./waitForReplicationInstanceAvailable";
 export * from "./waitForReplicationInstanceDeleted";
 export * from "./waitForReplicationTaskDeleted";

package/dist-es/waiters/waitForExtensionPackAssociated.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeExtensionPackAssociationsCommand, } from "../commands/DescribeExtensionPackAssociationsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new DescribeExtensionPackAssociationsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            let allStringEq_5 = (returnComparator().length > 0);
+            for (let element_4 of returnComparator()) {
+                allStringEq_5 = allStringEq_5 && (element_4 == "SUCCESS");
+            }
+            if (allStringEq_5) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.Requests);
+                let projection_3 = flat_1.map((element_2) => {
+                    return element_2.Status;
+                });
+                return projection_3;
+            };
+            for (let 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 waitForExtensionPackAssociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilExtensionPackAssociated = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};