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

package/dist-cjs/commands/RestoreGraphFromSnapshotCommand.js

@@ -5,48 +5,25 @@ const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
 const middleware_serde_1 = require("@smithy/middleware-serde");
 const smithy_client_1 = require("@smithy/smithy-client");
 Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
-const types_1 = require("@smithy/types");
+const EndpointParameters_1 = require("../endpoint/EndpointParameters");
 const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
-class RestoreGraphFromSnapshotCommand extends smithy_client_1.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((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use((0, middleware_endpoint_1.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: (_) => _,
-            [types_1.SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "RestoreGraphFromSnapshot",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return (0, Aws_restJson1_1.se_RestoreGraphFromSnapshotCommand)(input, context);
-    }
-    deserialize(output, context) {
-        return (0, Aws_restJson1_1.de_RestoreGraphFromSnapshotCommand)(output, context);
-    }
+class RestoreGraphFromSnapshotCommand extends smithy_client_1.Command
+    .classBuilder()
+    .ep({
+    ...EndpointParameters_1.commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize),
+        (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "RestoreGraphFromSnapshot", {})
+    .n("NeptuneGraphClient", "RestoreGraphFromSnapshotCommand")
+    .f(void 0, void 0)
+    .ser(Aws_restJson1_1.se_RestoreGraphFromSnapshotCommand)
+    .de(Aws_restJson1_1.de_RestoreGraphFromSnapshotCommand)
+    .build() {
 }
 exports.RestoreGraphFromSnapshotCommand = RestoreGraphFromSnapshotCommand;

package/dist-cjs/commands/TagResourceCommand.js

@@ -5,48 +5,25 @@ const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
 const middleware_serde_1 = require("@smithy/middleware-serde");
 const smithy_client_1 = require("@smithy/smithy-client");
 Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
-const types_1 = require("@smithy/types");
+const EndpointParameters_1 = require("../endpoint/EndpointParameters");
 const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
-class TagResourceCommand extends smithy_client_1.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((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use((0, middleware_endpoint_1.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: (_) => _,
-            [types_1.SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "TagResource",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return (0, Aws_restJson1_1.se_TagResourceCommand)(input, context);
-    }
-    deserialize(output, context) {
-        return (0, Aws_restJson1_1.de_TagResourceCommand)(output, context);
-    }
+class TagResourceCommand extends smithy_client_1.Command
+    .classBuilder()
+    .ep({
+    ...EndpointParameters_1.commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize),
+        (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "TagResource", {})
+    .n("NeptuneGraphClient", "TagResourceCommand")
+    .f(void 0, void 0)
+    .ser(Aws_restJson1_1.se_TagResourceCommand)
+    .de(Aws_restJson1_1.de_TagResourceCommand)
+    .build() {
 }
 exports.TagResourceCommand = TagResourceCommand;

package/dist-cjs/commands/UntagResourceCommand.js

@@ -5,48 +5,25 @@ const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
 const middleware_serde_1 = require("@smithy/middleware-serde");
 const smithy_client_1 = require("@smithy/smithy-client");
 Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
-const types_1 = require("@smithy/types");
+const EndpointParameters_1 = require("../endpoint/EndpointParameters");
 const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
-class UntagResourceCommand extends smithy_client_1.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((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use((0, middleware_endpoint_1.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: (_) => _,
-            [types_1.SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "UntagResource",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return (0, Aws_restJson1_1.se_UntagResourceCommand)(input, context);
-    }
-    deserialize(output, context) {
-        return (0, Aws_restJson1_1.de_UntagResourceCommand)(output, context);
-    }
+class UntagResourceCommand extends smithy_client_1.Command
+    .classBuilder()
+    .ep({
+    ...EndpointParameters_1.commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize),
+        (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "UntagResource", {})
+    .n("NeptuneGraphClient", "UntagResourceCommand")
+    .f(void 0, void 0)
+    .ser(Aws_restJson1_1.se_UntagResourceCommand)
+    .de(Aws_restJson1_1.de_UntagResourceCommand)
+    .build() {
 }
 exports.UntagResourceCommand = UntagResourceCommand;

package/dist-cjs/commands/UpdateGraphCommand.js

@@ -5,48 +5,25 @@ const middleware_endpoint_1 = require("@smithy/middleware-endpoint");
 const middleware_serde_1 = require("@smithy/middleware-serde");
 const smithy_client_1 = require("@smithy/smithy-client");
 Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } });
-const types_1 = require("@smithy/types");
+const EndpointParameters_1 = require("../endpoint/EndpointParameters");
 const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
-class UpdateGraphCommand extends smithy_client_1.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((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use((0, middleware_endpoint_1.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: (_) => _,
-            [types_1.SMITHY_CONTEXT_KEY]: {
-                service: "AmazonNeptuneGraph",
-                operation: "UpdateGraph",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return (0, Aws_restJson1_1.se_UpdateGraphCommand)(input, context);
-    }
-    deserialize(output, context) {
-        return (0, Aws_restJson1_1.de_UpdateGraphCommand)(output, context);
-    }
+class UpdateGraphCommand extends smithy_client_1.Command
+    .classBuilder()
+    .ep({
+    ...EndpointParameters_1.commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize),
+        (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "UpdateGraph", {})
+    .n("NeptuneGraphClient", "UpdateGraphCommand")
+    .f(void 0, void 0)
+    .ser(Aws_restJson1_1.se_UpdateGraphCommand)
+    .de(Aws_restJson1_1.de_UpdateGraphCommand)
+    .build() {
 }
 exports.UpdateGraphCommand = UpdateGraphCommand;

package/dist-cjs/endpoint/EndpointParameters.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveClientEndpointParameters = void 0;
+exports.commonParams = exports.resolveClientEndpointParameters = void 0;
 const resolveClientEndpointParameters = (options) => {
     return {
         ...options,
@@ -10,3 +10,9 @@ const resolveClientEndpointParameters = (options) => {
     };
 };
 exports.resolveClientEndpointParameters = resolveClientEndpointParameters;
+exports.commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+};

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ tslib_1.__exportStar(require("./NeptuneGraphClient"), exports);
 tslib_1.__exportStar(require("./NeptuneGraph"), exports);
 tslib_1.__exportStar(require("./commands"), exports);
 tslib_1.__exportStar(require("./pagination"), exports);
+tslib_1.__exportStar(require("./waiters"), exports);
 tslib_1.__exportStar(require("./models"), exports);
 require("@aws-sdk/util-endpoints");
 var NeptuneGraphServiceException_1 = require("./models/NeptuneGraphServiceException");

package/dist-cjs/waiters/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./waitForGraphAvailable"), exports);
+tslib_1.__exportStar(require("./waitForGraphDeleted"), exports);
+tslib_1.__exportStar(require("./waitForGraphSnapshotAvailable"), exports);
+tslib_1.__exportStar(require("./waitForGraphSnapshotDeleted"), exports);
+tslib_1.__exportStar(require("./waitForImportTaskCancelled"), exports);
+tslib_1.__exportStar(require("./waitForImportTaskSuccessful"), exports);
+tslib_1.__exportStar(require("./waitForPrivateGraphEndpointAvailable"), exports);
+tslib_1.__exportStar(require("./waitForPrivateGraphEndpointDeleted"), exports);

package/dist-cjs/waiters/waitForGraphAvailable.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilGraphAvailable = exports.waitForGraphAvailable = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetGraphCommand_1 = require("../commands/GetGraphCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphCommand_1.GetGraphCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "AVAILABLE") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForGraphAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForGraphAvailable = waitForGraphAvailable;
+const waitUntilGraphAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilGraphAvailable = waitUntilGraphAvailable;

package/dist-cjs/waiters/waitForGraphDeleted.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilGraphDeleted = exports.waitForGraphDeleted = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetGraphCommand_1 = require("../commands/GetGraphCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphCommand_1.GetGraphCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status != "DELETING";
+            };
+            if (returnComparator() == true) {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForGraphDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForGraphDeleted = waitForGraphDeleted;
+const waitUntilGraphDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilGraphDeleted = waitUntilGraphDeleted;

package/dist-cjs/waiters/waitForGraphSnapshotAvailable.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilGraphSnapshotAvailable = exports.waitForGraphSnapshotAvailable = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetGraphSnapshotCommand_1 = require("../commands/GetGraphSnapshotCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphSnapshotCommand_1.GetGraphSnapshotCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "AVAILABLE") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForGraphSnapshotAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForGraphSnapshotAvailable = waitForGraphSnapshotAvailable;
+const waitUntilGraphSnapshotAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilGraphSnapshotAvailable = waitUntilGraphSnapshotAvailable;

package/dist-cjs/waiters/waitForGraphSnapshotDeleted.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilGraphSnapshotDeleted = exports.waitForGraphSnapshotDeleted = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetGraphSnapshotCommand_1 = require("../commands/GetGraphSnapshotCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetGraphSnapshotCommand_1.GetGraphSnapshotCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status != "DELETING";
+            };
+            if (returnComparator() == true) {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForGraphSnapshotDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForGraphSnapshotDeleted = waitForGraphSnapshotDeleted;
+const waitUntilGraphSnapshotDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilGraphSnapshotDeleted = waitUntilGraphSnapshotDeleted;

package/dist-cjs/waiters/waitForImportTaskCancelled.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilImportTaskCancelled = exports.waitForImportTaskCancelled = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetImportTaskCommand_1 = require("../commands/GetImportTaskCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetImportTaskCommand_1.GetImportTaskCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status != "CANCELLING";
+            };
+            if (returnComparator() == true) {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "CANCELLED") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForImportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForImportTaskCancelled = waitForImportTaskCancelled;
+const waitUntilImportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilImportTaskCancelled = waitUntilImportTaskCancelled;

package/dist-cjs/waiters/waitForImportTaskSuccessful.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilImportTaskSuccessful = exports.waitForImportTaskSuccessful = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetImportTaskCommand_1 = require("../commands/GetImportTaskCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetImportTaskCommand_1.GetImportTaskCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "CANCELLING") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "CANCELLED") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "ROLLING_BACK") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "SUCCEEDED") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForImportTaskSuccessful = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForImportTaskSuccessful = waitForImportTaskSuccessful;
+const waitUntilImportTaskSuccessful = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilImportTaskSuccessful = waitUntilImportTaskSuccessful;