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

package/dist-es/waiters/waitForMetadataModelAssessed.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeMetadataModelAssessmentsCommand, } from "../commands/DescribeMetadataModelAssessmentsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.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: 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 waitForMetadataModelAssessed = async (params, input) => {
+    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMetadataModelAssessed = async (params, input) => {
+    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMetadataModelConversionCancelled.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeMetadataModelConversionsCommand, } from "../commands/DescribeMetadataModelConversionsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.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: 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 waitForMetadataModelConversionCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMetadataModelConversionCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMetadataModelConverted.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeMetadataModelConversionsCommand, } from "../commands/DescribeMetadataModelConversionsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.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: 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 waitForMetadataModelConverted = async (params, input) => {
+    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMetadataModelConverted = async (params, input) => {
+    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMetadataModelCreated.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeMetadataModelCreationsCommand, } from "../commands/DescribeMetadataModelCreationsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.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: 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 waitForMetadataModelCreated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMetadataModelCreated = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMetadataModelCreationCancelled.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeMetadataModelCreationsCommand, } from "../commands/DescribeMetadataModelCreationsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.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: 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 waitForMetadataModelCreationCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMetadataModelCreationCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMetadataModelExportedAsScript.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeMetadataModelExportsAsScriptCommand, } from "../commands/DescribeMetadataModelExportsAsScriptCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.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: 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 waitForMetadataModelExportedAsScript = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMetadataModelExportedAsScript = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMetadataModelExportedToTarget.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeMetadataModelExportsToTargetCommand, } from "../commands/DescribeMetadataModelExportsToTargetCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.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: 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 waitForMetadataModelExportedToTarget = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMetadataModelExportedToTarget = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMetadataModelImported.js

@@ -0,0 +1,54 @@
+import { checkExceptions, createWaiter, WaiterState, } from "@smithy/core/client";
+import { DescribeMetadataModelImportsCommand, } from "../commands/DescribeMetadataModelImportsCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.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: 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 waitForMetadataModelImported = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMetadataModelImported = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-types/DatabaseMigrationService.d.ts

@@ -1178,6 +1178,60 @@ export interface DatabaseMigrationService {
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
     waitUntilEndpointDeleted(args: DescribeEndpointsCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<ResourceNotFoundFault>>;
+    /**
+     * @see {@link DescribeExtensionPackAssociationsCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilExtensionPackAssociated(args: DescribeExtensionPackAssociationsCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeExtensionPackAssociationsCommandOutput>>;
+    /**
+     * @see {@link DescribeMetadataModelAssessmentsCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilMetadataModelAssessed(args: DescribeMetadataModelAssessmentsCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeMetadataModelAssessmentsCommandOutput>>;
+    /**
+     * @see {@link DescribeMetadataModelConversionsCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilMetadataModelConversionCancelled(args: DescribeMetadataModelConversionsCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeMetadataModelConversionsCommandOutput>>;
+    /**
+     * @see {@link DescribeMetadataModelConversionsCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilMetadataModelConverted(args: DescribeMetadataModelConversionsCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeMetadataModelConversionsCommandOutput>>;
+    /**
+     * @see {@link DescribeMetadataModelCreationsCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilMetadataModelCreated(args: DescribeMetadataModelCreationsCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeMetadataModelCreationsCommandOutput>>;
+    /**
+     * @see {@link DescribeMetadataModelCreationsCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilMetadataModelCreationCancelled(args: DescribeMetadataModelCreationsCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeMetadataModelCreationsCommandOutput>>;
+    /**
+     * @see {@link DescribeMetadataModelExportsAsScriptCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilMetadataModelExportedAsScript(args: DescribeMetadataModelExportsAsScriptCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeMetadataModelExportsAsScriptCommandOutput>>;
+    /**
+     * @see {@link DescribeMetadataModelExportsToTargetCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilMetadataModelExportedToTarget(args: DescribeMetadataModelExportsToTargetCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeMetadataModelExportsToTargetCommandOutput>>;
+    /**
+     * @see {@link DescribeMetadataModelImportsCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilMetadataModelImported(args: DescribeMetadataModelImportsCommandInput, waiterConfig: number | Omit<WaiterConfiguration<DatabaseMigrationService>, "client">): Promise<WaiterResult<DescribeMetadataModelImportsCommandOutput>>;
     /**
      * @see {@link DescribeReplicationInstancesCommand}
      * @param args - command input.

package/dist-types/ts3.4/DatabaseMigrationService.d.ts

@@ -2475,6 +2475,87 @@ export interface DatabaseMigrationService {
           Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
         >
   ): Promise<WaiterResult<ResourceNotFoundFault>>;
+  waitUntilExtensionPackAssociated(
+    args: DescribeExtensionPackAssociationsCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeExtensionPackAssociationsCommandOutput>>;
+  waitUntilMetadataModelAssessed(
+    args: DescribeMetadataModelAssessmentsCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeMetadataModelAssessmentsCommandOutput>>;
+  waitUntilMetadataModelConversionCancelled(
+    args: DescribeMetadataModelConversionsCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeMetadataModelConversionsCommandOutput>>;
+  waitUntilMetadataModelConverted(
+    args: DescribeMetadataModelConversionsCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeMetadataModelConversionsCommandOutput>>;
+  waitUntilMetadataModelCreated(
+    args: DescribeMetadataModelCreationsCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeMetadataModelCreationsCommandOutput>>;
+  waitUntilMetadataModelCreationCancelled(
+    args: DescribeMetadataModelCreationsCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeMetadataModelCreationsCommandOutput>>;
+  waitUntilMetadataModelExportedAsScript(
+    args: DescribeMetadataModelExportsAsScriptCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeMetadataModelExportsAsScriptCommandOutput>>;
+  waitUntilMetadataModelExportedToTarget(
+    args: DescribeMetadataModelExportsToTargetCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeMetadataModelExportsToTargetCommandOutput>>;
+  waitUntilMetadataModelImported(
+    args: DescribeMetadataModelImportsCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<DatabaseMigrationService>,
+          Exclude<keyof WaiterConfiguration<DatabaseMigrationService>, "client">
+        >
+  ): Promise<WaiterResult<DescribeMetadataModelImportsCommandOutput>>;
   waitUntilReplicationInstanceAvailable(
     args: DescribeReplicationInstancesCommandInput,
     waiterConfig:

package/dist-types/ts3.4/waiters/index.d.ts

@@ -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-types/ts3.4/waiters/waitForExtensionPackAssociated.d.ts

@@ -0,0 +1,20 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/core/client";
+import {
+  DescribeExtensionPackAssociationsCommandInput,
+  DescribeExtensionPackAssociationsCommandOutput,
+} from "../commands/DescribeExtensionPackAssociationsCommand";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServiceServiceException } from "../models/DatabaseMigrationServiceServiceException";
+export declare const waitForExtensionPackAssociated: (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeExtensionPackAssociationsCommandInput
+) => Promise<
+  WaiterResult<
+    | DescribeExtensionPackAssociationsCommandOutput
+    | DatabaseMigrationServiceServiceException
+  >
+>;
+export declare const waitUntilExtensionPackAssociated: (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeExtensionPackAssociationsCommandInput
+) => Promise<WaiterResult<DescribeExtensionPackAssociationsCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForMetadataModelAssessed.d.ts

@@ -0,0 +1,20 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/core/client";
+import {
+  DescribeMetadataModelAssessmentsCommandInput,
+  DescribeMetadataModelAssessmentsCommandOutput,
+} from "../commands/DescribeMetadataModelAssessmentsCommand";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServiceServiceException } from "../models/DatabaseMigrationServiceServiceException";
+export declare const waitForMetadataModelAssessed: (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeMetadataModelAssessmentsCommandInput
+) => Promise<
+  WaiterResult<
+    | DescribeMetadataModelAssessmentsCommandOutput
+    | DatabaseMigrationServiceServiceException
+  >
+>;
+export declare const waitUntilMetadataModelAssessed: (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeMetadataModelAssessmentsCommandInput
+) => Promise<WaiterResult<DescribeMetadataModelAssessmentsCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForMetadataModelConversionCancelled.d.ts

@@ -0,0 +1,20 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/core/client";
+import {
+  DescribeMetadataModelConversionsCommandInput,
+  DescribeMetadataModelConversionsCommandOutput,
+} from "../commands/DescribeMetadataModelConversionsCommand";
+import { DatabaseMigrationServiceClient } from "../DatabaseMigrationServiceClient";
+import { DatabaseMigrationServiceServiceException } from "../models/DatabaseMigrationServiceServiceException";
+export declare const waitForMetadataModelConversionCancelled: (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeMetadataModelConversionsCommandInput
+) => Promise<
+  WaiterResult<
+    | DescribeMetadataModelConversionsCommandOutput
+    | DatabaseMigrationServiceServiceException
+  >
+>;
+export declare const waitUntilMetadataModelConversionCancelled: (
+  params: WaiterConfiguration<DatabaseMigrationServiceClient>,
+  input: DescribeMetadataModelConversionsCommandInput
+) => Promise<WaiterResult<DescribeMetadataModelConversionsCommandOutput>>;