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

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/DatabaseMigrationServiceClient.js

@@ -1,7 +1,4 @@
-import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
-import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
-import { getRecursionDetectionPlugin } from "@aws-sdk/middleware-recursion-detection";
-import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, getUserAgentPlugin, resolveHostHeaderConfig, resolveUserAgentConfig, } from "@aws-sdk/core/client";
 import { DefaultIdentityProviderConfig, getHttpAuthSchemeEndpointRuleSetPlugin, getHttpSigningPlugin, } from "@smithy/core";
 import { Client as __Client, } from "@smithy/core/client";
 import { resolveRegionConfig } from "@smithy/core/config";

package/dist-es/endpoint/endpointResolver.js

@@ -1,4 +1,4 @@
-import { awsEndpointFunctions } from "@aws-sdk/util-endpoints";
+import { awsEndpointFunctions } from "@aws-sdk/core/client";
 import { customEndpointFunctions, decideEndpoint, EndpointCache } from "@smithy/core/endpoints";
 import { bdd } from "./bdd";
 const cache = new EndpointCache({

package/dist-es/runtimeConfig.browser.js

@@ -1,6 +1,6 @@
 import packageInfo from "../package.json";
 import { Sha256 } from "@aws-crypto/sha256-browser";
-import { createDefaultUserAgentProvider } from "@aws-sdk/util-user-agent-browser";
+import { createDefaultUserAgentProvider } from "@aws-sdk/core/client";
 import { invalidProvider, loadConfigsForDefaultMode } from "@smithy/core/client";
 import { DEFAULT_USE_DUALSTACK_ENDPOINT, DEFAULT_USE_FIPS_ENDPOINT, resolveDefaultsModeConfig, } from "@smithy/core/config";
 import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "@smithy/core/retry";

package/dist-es/runtimeConfig.js

@@ -1,8 +1,7 @@
 import packageInfo from "../package.json";
-import { emitWarningIfUnsupportedVersion as awsCheckVersion } from "@aws-sdk/core/client";
+import { createDefaultUserAgentProvider, emitWarningIfUnsupportedVersion as awsCheckVersion, NODE_APP_ID_CONFIG_OPTIONS, } from "@aws-sdk/core/client";
 import { NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } from "@aws-sdk/core/httpAuthSchemes";
 import { defaultProvider as credentialDefaultProvider } from "@aws-sdk/credential-provider-node";
-import { createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS } from "@aws-sdk/util-user-agent-node";
 import { emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode } from "@smithy/core/client";
 import { loadConfig as loadNodeConfig, NODE_REGION_CONFIG_FILE_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, resolveDefaultsModeConfig, } from "@smithy/core/config";
 import { DEFAULT_RETRY_MODE, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, NODE_RETRY_MODE_CONFIG_OPTIONS, } from "@smithy/core/retry";

package/dist-es/runtimeExtensions.js

@@ -1,4 +1,4 @@
-import { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, } from "@aws-sdk/region-config-resolver";
+import { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration } from "@aws-sdk/core/client";
 import { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig } from "@smithy/core/client";
 import { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig } from "@smithy/core/protocols";
 import { getHttpAuthExtensionConfiguration, resolveHttpAuthRuntimeConfig } from "./auth/httpAuthExtensionConfiguration";

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);
+};

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/DatabaseMigrationServiceClient.d.ts

@@ -1,5 +1,4 @@
-import { type HostHeaderInputConfig, type HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
-import { type UserAgentInputConfig, type UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { type HostHeaderInputConfig, type HostHeaderResolvedConfig, type UserAgentInputConfig, type UserAgentResolvedConfig } from "@aws-sdk/core/client";
 import { type DefaultsMode as __DefaultsMode, type SmithyConfiguration as __SmithyConfiguration, type SmithyResolvedConfiguration as __SmithyResolvedConfiguration, Client as __Client } from "@smithy/core/client";
 import { type RegionInputConfig, type RegionResolvedConfig } from "@smithy/core/config";
 import { type EndpointInputConfig, type EndpointResolvedConfig } from "@smithy/core/endpoints";