@aws-sdk/client-neptune-graph 3.478.0 → 3.481.0

package/dist-es/commands/ResetGraphCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_ResetGraphCommand, se_ResetGraphCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class ResetGraphCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            ApiType: { type: "staticContextParams", value: `ControlPlane` },
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, ResetGraphCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "ResetGraphCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "ResetGraph",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_ResetGraphCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_ResetGraphCommand(output, context);
-    }
+export class ResetGraphCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "ResetGraph", {})
+    .n("NeptuneGraphClient", "ResetGraphCommand")
+    .f(void 0, void 0)
+    .ser(se_ResetGraphCommand)
+    .de(de_ResetGraphCommand)
+    .build() {
 }

package/dist-es/commands/RestoreGraphFromSnapshotCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_RestoreGraphFromSnapshotCommand, se_RestoreGraphFromSnapshotCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class RestoreGraphFromSnapshotCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            ApiType: { type: "staticContextParams", value: `ControlPlane` },
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, RestoreGraphFromSnapshotCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "RestoreGraphFromSnapshotCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "RestoreGraphFromSnapshot",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RestoreGraphFromSnapshotCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RestoreGraphFromSnapshotCommand(output, context);
-    }
+export class RestoreGraphFromSnapshotCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "RestoreGraphFromSnapshot", {})
+    .n("NeptuneGraphClient", "RestoreGraphFromSnapshotCommand")
+    .f(void 0, void 0)
+    .ser(se_RestoreGraphFromSnapshotCommand)
+    .de(de_RestoreGraphFromSnapshotCommand)
+    .build() {
 }

package/dist-es/commands/TagResourceCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_TagResourceCommand, se_TagResourceCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class TagResourceCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            ApiType: { type: "staticContextParams", value: `ControlPlane` },
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, TagResourceCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "TagResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "TagResource",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_TagResourceCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_TagResourceCommand(output, context);
-    }
+export class TagResourceCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "TagResource", {})
+    .n("NeptuneGraphClient", "TagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_TagResourceCommand)
+    .de(de_TagResourceCommand)
+    .build() {
 }

package/dist-es/commands/UntagResourceCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UntagResourceCommand, se_UntagResourceCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class UntagResourceCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            ApiType: { type: "staticContextParams", value: `ControlPlane` },
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UntagResourceCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "UntagResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "UntagResource",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UntagResourceCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UntagResourceCommand(output, context);
-    }
+export class UntagResourceCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "UntagResource", {})
+    .n("NeptuneGraphClient", "UntagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_UntagResourceCommand)
+    .de(de_UntagResourceCommand)
+    .build() {
 }

package/dist-es/commands/UpdateGraphCommand.js

@@ -1,48 +1,25 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UpdateGraphCommand, se_UpdateGraphCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class UpdateGraphCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            ApiType: { type: "staticContextParams", value: `ControlPlane` },
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateGraphCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "NeptuneGraphClient";
-        const commandName = "UpdateGraphCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "UpdateGraph",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UpdateGraphCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UpdateGraphCommand(output, context);
-    }
+export class UpdateGraphCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "UpdateGraph", {})
+    .n("NeptuneGraphClient", "UpdateGraphCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateGraphCommand)
+    .de(de_UpdateGraphCommand)
+    .build() {
 }

package/dist-es/endpoint/EndpointParameters.js

@@ -6,3 +6,9 @@ export const resolveClientEndpointParameters = (options) => {
         defaultSigningName: "neptune-graph",
     };
 };
+export const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+};

package/dist-es/index.js

@@ -2,6 +2,7 @@ export * from "./NeptuneGraphClient";
 export * from "./NeptuneGraph";
 export * from "./commands";
 export * from "./pagination";
+export * from "./waiters";
 export * from "./models";
 import "@aws-sdk/util-endpoints";
 export { NeptuneGraphServiceException } from "./models/NeptuneGraphServiceException";

package/dist-es/waiters/index.js

@@ -0,0 +1,8 @@
+export * from "./waitForGraphAvailable";
+export * from "./waitForGraphDeleted";
+export * from "./waitForGraphSnapshotAvailable";
+export * from "./waitForGraphSnapshotDeleted";
+export * from "./waitForImportTaskCancelled";
+export * from "./waitForImportTaskSuccessful";
+export * from "./waitForPrivateGraphEndpointAvailable";
+export * from "./waitForPrivateGraphEndpointDeleted";

package/dist-es/waiters/waitForGraphAvailable.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetGraphCommand } from "../commands/GetGraphCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "AVAILABLE") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForGraphAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilGraphAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForGraphDeleted.js

@@ -0,0 +1,34 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetGraphCommand } from "../commands/GetGraphCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status != "DELETING";
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForGraphDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilGraphDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForGraphSnapshotAvailable.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetGraphSnapshotCommand } from "../commands/GetGraphSnapshotCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphSnapshotCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "AVAILABLE") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForGraphSnapshotAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilGraphSnapshotAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForGraphSnapshotDeleted.js

@@ -0,0 +1,34 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetGraphSnapshotCommand } from "../commands/GetGraphSnapshotCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphSnapshotCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status != "DELETING";
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForGraphSnapshotDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilGraphSnapshotDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForImportTaskCancelled.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetImportTaskCommand } from "../commands/GetImportTaskCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetImportTaskCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status != "CANCELLING";
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "CANCELLED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForImportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilImportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForImportTaskSuccessful.js

@@ -0,0 +1,67 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetImportTaskCommand } from "../commands/GetImportTaskCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetImportTaskCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "CANCELLING") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "CANCELLED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "ROLLING_BACK") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "SUCCEEDED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForImportTaskSuccessful = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilImportTaskSuccessful = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};