@aws-sdk/client-sagemaker 3.183.0 → 3.185.0

package/dist-es/waiters/waitForImageVersionCreated.js

@@ -1,43 +1,63 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { checkExceptions, createWaiter, WaiterState } from "@aws-sdk/util-waiter";
 import { DescribeImageVersionCommand } from "../commands/DescribeImageVersionCommand";
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new DescribeImageVersionCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.ImageVersionStatus;
-            };
-            if (returnComparator() === "CREATED") {
-                return { state: WaiterState.SUCCESS, reason };
-            }
+var checkState = function (client, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var reason, result_1, returnComparator, returnComparator, exception_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4, client.send(new DescribeImageVersionCommand(input))];
+            case 1:
+                result_1 = _a.sent();
+                reason = result_1;
+                try {
+                    returnComparator = function () {
+                        return result_1.ImageVersionStatus;
+                    };
+                    if (returnComparator() === "CREATED") {
+                        return [2, { state: WaiterState.SUCCESS, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                try {
+                    returnComparator = function () {
+                        return result_1.ImageVersionStatus;
+                    };
+                    if (returnComparator() === "CREATE_FAILED") {
+                        return [2, { state: WaiterState.FAILURE, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                return [3, 3];
+            case 2:
+                exception_1 = _a.sent();
+                reason = exception_1;
+                if (exception_1.name && exception_1.name == "ValidationException") {
+                    return [2, { state: WaiterState.FAILURE, reason: reason }];
+                }
+                return [3, 3];
+            case 3: return [2, { state: WaiterState.RETRY, reason: reason }];
         }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.ImageVersionStatus;
-            };
-            if (returnComparator() === "CREATE_FAILED") {
-                return { state: WaiterState.FAILURE, reason };
-            }
+    });
+}); };
+export var waitForImageVersionCreated = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults;
+    return __generator(this, function (_a) {
+        serviceDefaults = { minDelay: 60, maxDelay: 120 };
+        return [2, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+    });
+}); };
+export var waitUntilImageVersionCreated = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                serviceDefaults = { minDelay: 60, maxDelay: 120 };
+                return [4, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+            case 1:
+                result = _a.sent();
+                return [2, checkExceptions(result)];
         }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-        if (exception.name && exception.name == "ValidationException") {
-            return { state: WaiterState.FAILURE, reason };
-        }
-    }
-    return { state: WaiterState.RETRY, reason };
-};
-export const waitForImageVersionCreated = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-};
-export const waitUntilImageVersionCreated = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
-    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return checkExceptions(result);
-};
+    });
+}); };

package/dist-es/waiters/waitForImageVersionDeleted.js

@@ -1,37 +1,57 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { checkExceptions, createWaiter, WaiterState } from "@aws-sdk/util-waiter";
 import { DescribeImageVersionCommand } from "../commands/DescribeImageVersionCommand";
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new DescribeImageVersionCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.ImageVersionStatus;
-            };
-            if (returnComparator() === "DELETE_FAILED") {
-                return { state: WaiterState.FAILURE, reason };
-            }
+var checkState = function (client, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var reason, result_1, returnComparator, exception_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4, client.send(new DescribeImageVersionCommand(input))];
+            case 1:
+                result_1 = _a.sent();
+                reason = result_1;
+                try {
+                    returnComparator = function () {
+                        return result_1.ImageVersionStatus;
+                    };
+                    if (returnComparator() === "DELETE_FAILED") {
+                        return [2, { state: WaiterState.FAILURE, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                return [3, 3];
+            case 2:
+                exception_1 = _a.sent();
+                reason = exception_1;
+                if (exception_1.name && exception_1.name == "ResourceNotFoundException") {
+                    return [2, { state: WaiterState.SUCCESS, reason: reason }];
+                }
+                if (exception_1.name && exception_1.name == "ValidationException") {
+                    return [2, { state: WaiterState.FAILURE, reason: reason }];
+                }
+                return [3, 3];
+            case 3: return [2, { state: WaiterState.RETRY, reason: reason }];
         }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-        if (exception.name && exception.name == "ResourceNotFoundException") {
-            return { state: WaiterState.SUCCESS, reason };
+    });
+}); };
+export var waitForImageVersionDeleted = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults;
+    return __generator(this, function (_a) {
+        serviceDefaults = { minDelay: 60, maxDelay: 120 };
+        return [2, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+    });
+}); };
+export var waitUntilImageVersionDeleted = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                serviceDefaults = { minDelay: 60, maxDelay: 120 };
+                return [4, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+            case 1:
+                result = _a.sent();
+                return [2, checkExceptions(result)];
         }
-        if (exception.name && exception.name == "ValidationException") {
-            return { state: WaiterState.FAILURE, reason };
-        }
-    }
-    return { state: WaiterState.RETRY, reason };
-};
-export const waitForImageVersionDeleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-};
-export const waitUntilImageVersionDeleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
-    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return checkExceptions(result);
-};
+    });
+}); };

package/dist-es/waiters/waitForNotebookInstanceDeleted.js

@@ -1,34 +1,54 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { checkExceptions, createWaiter, WaiterState } from "@aws-sdk/util-waiter";
 import { DescribeNotebookInstanceCommand, } from "../commands/DescribeNotebookInstanceCommand";
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new DescribeNotebookInstanceCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.NotebookInstanceStatus;
-            };
-            if (returnComparator() === "Failed") {
-                return { state: WaiterState.FAILURE, reason };
-            }
+var checkState = function (client, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var reason, result_1, returnComparator, exception_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4, client.send(new DescribeNotebookInstanceCommand(input))];
+            case 1:
+                result_1 = _a.sent();
+                reason = result_1;
+                try {
+                    returnComparator = function () {
+                        return result_1.NotebookInstanceStatus;
+                    };
+                    if (returnComparator() === "Failed") {
+                        return [2, { state: WaiterState.FAILURE, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                return [3, 3];
+            case 2:
+                exception_1 = _a.sent();
+                reason = exception_1;
+                if (exception_1.name && exception_1.name == "ValidationException") {
+                    return [2, { state: WaiterState.SUCCESS, reason: reason }];
+                }
+                return [3, 3];
+            case 3: return [2, { state: WaiterState.RETRY, reason: reason }];
         }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-        if (exception.name && exception.name == "ValidationException") {
-            return { state: WaiterState.SUCCESS, reason };
+    });
+}); };
+export var waitForNotebookInstanceDeleted = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults;
+    return __generator(this, function (_a) {
+        serviceDefaults = { minDelay: 30, maxDelay: 120 };
+        return [2, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+    });
+}); };
+export var waitUntilNotebookInstanceDeleted = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                serviceDefaults = { minDelay: 30, maxDelay: 120 };
+                return [4, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+            case 1:
+                result = _a.sent();
+                return [2, checkExceptions(result)];
         }
-    }
-    return { state: WaiterState.RETRY, reason };
-};
-export const waitForNotebookInstanceDeleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-};
-export const waitUntilNotebookInstanceDeleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return checkExceptions(result);
-};
+    });
+}); };

package/dist-es/waiters/waitForNotebookInstanceInService.js

@@ -1,40 +1,60 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { checkExceptions, createWaiter, WaiterState } from "@aws-sdk/util-waiter";
 import { DescribeNotebookInstanceCommand, } from "../commands/DescribeNotebookInstanceCommand";
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new DescribeNotebookInstanceCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.NotebookInstanceStatus;
-            };
-            if (returnComparator() === "InService") {
-                return { state: WaiterState.SUCCESS, reason };
-            }
+var checkState = function (client, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var reason, result_1, returnComparator, returnComparator, exception_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4, client.send(new DescribeNotebookInstanceCommand(input))];
+            case 1:
+                result_1 = _a.sent();
+                reason = result_1;
+                try {
+                    returnComparator = function () {
+                        return result_1.NotebookInstanceStatus;
+                    };
+                    if (returnComparator() === "InService") {
+                        return [2, { state: WaiterState.SUCCESS, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                try {
+                    returnComparator = function () {
+                        return result_1.NotebookInstanceStatus;
+                    };
+                    if (returnComparator() === "Failed") {
+                        return [2, { state: WaiterState.FAILURE, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                return [3, 3];
+            case 2:
+                exception_1 = _a.sent();
+                reason = exception_1;
+                return [3, 3];
+            case 3: return [2, { state: WaiterState.RETRY, reason: reason }];
         }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.NotebookInstanceStatus;
-            };
-            if (returnComparator() === "Failed") {
-                return { state: WaiterState.FAILURE, reason };
-            }
+    });
+}); };
+export var waitForNotebookInstanceInService = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults;
+    return __generator(this, function (_a) {
+        serviceDefaults = { minDelay: 30, maxDelay: 120 };
+        return [2, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+    });
+}); };
+export var waitUntilNotebookInstanceInService = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                serviceDefaults = { minDelay: 30, maxDelay: 120 };
+                return [4, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+            case 1:
+                result = _a.sent();
+                return [2, checkExceptions(result)];
         }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: WaiterState.RETRY, reason };
-};
-export const waitForNotebookInstanceInService = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-};
-export const waitUntilNotebookInstanceInService = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return checkExceptions(result);
-};
+    });
+}); };

package/dist-es/waiters/waitForNotebookInstanceStopped.js

@@ -1,40 +1,60 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { checkExceptions, createWaiter, WaiterState } from "@aws-sdk/util-waiter";
 import { DescribeNotebookInstanceCommand, } from "../commands/DescribeNotebookInstanceCommand";
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new DescribeNotebookInstanceCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.NotebookInstanceStatus;
-            };
-            if (returnComparator() === "Stopped") {
-                return { state: WaiterState.SUCCESS, reason };
-            }
+var checkState = function (client, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var reason, result_1, returnComparator, returnComparator, exception_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4, client.send(new DescribeNotebookInstanceCommand(input))];
+            case 1:
+                result_1 = _a.sent();
+                reason = result_1;
+                try {
+                    returnComparator = function () {
+                        return result_1.NotebookInstanceStatus;
+                    };
+                    if (returnComparator() === "Stopped") {
+                        return [2, { state: WaiterState.SUCCESS, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                try {
+                    returnComparator = function () {
+                        return result_1.NotebookInstanceStatus;
+                    };
+                    if (returnComparator() === "Failed") {
+                        return [2, { state: WaiterState.FAILURE, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                return [3, 3];
+            case 2:
+                exception_1 = _a.sent();
+                reason = exception_1;
+                return [3, 3];
+            case 3: return [2, { state: WaiterState.RETRY, reason: reason }];
         }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.NotebookInstanceStatus;
-            };
-            if (returnComparator() === "Failed") {
-                return { state: WaiterState.FAILURE, reason };
-            }
+    });
+}); };
+export var waitForNotebookInstanceStopped = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults;
+    return __generator(this, function (_a) {
+        serviceDefaults = { minDelay: 30, maxDelay: 120 };
+        return [2, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+    });
+}); };
+export var waitUntilNotebookInstanceStopped = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                serviceDefaults = { minDelay: 30, maxDelay: 120 };
+                return [4, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+            case 1:
+                result = _a.sent();
+                return [2, checkExceptions(result)];
         }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: WaiterState.RETRY, reason };
-};
-export const waitForNotebookInstanceStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-};
-export const waitUntilNotebookInstanceStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 30, maxDelay: 120 };
-    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return checkExceptions(result);
-};
+    });
+}); };

package/dist-es/waiters/waitForProcessingJobCompletedOrStopped.js

@@ -1,52 +1,72 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { checkExceptions, createWaiter, WaiterState } from "@aws-sdk/util-waiter";
 import { DescribeProcessingJobCommand, } from "../commands/DescribeProcessingJobCommand";
-const checkState = async (client, input) => {
-    let reason;
-    try {
-        const result = await client.send(new DescribeProcessingJobCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.ProcessingJobStatus;
-            };
-            if (returnComparator() === "Completed") {
-                return { state: WaiterState.SUCCESS, reason };
-            }
+var checkState = function (client, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var reason, result_1, returnComparator, returnComparator, returnComparator, exception_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                return [4, client.send(new DescribeProcessingJobCommand(input))];
+            case 1:
+                result_1 = _a.sent();
+                reason = result_1;
+                try {
+                    returnComparator = function () {
+                        return result_1.ProcessingJobStatus;
+                    };
+                    if (returnComparator() === "Completed") {
+                        return [2, { state: WaiterState.SUCCESS, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                try {
+                    returnComparator = function () {
+                        return result_1.ProcessingJobStatus;
+                    };
+                    if (returnComparator() === "Stopped") {
+                        return [2, { state: WaiterState.SUCCESS, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                try {
+                    returnComparator = function () {
+                        return result_1.ProcessingJobStatus;
+                    };
+                    if (returnComparator() === "Failed") {
+                        return [2, { state: WaiterState.FAILURE, reason: reason }];
+                    }
+                }
+                catch (e) { }
+                return [3, 3];
+            case 2:
+                exception_1 = _a.sent();
+                reason = exception_1;
+                if (exception_1.name && exception_1.name == "ValidationException") {
+                    return [2, { state: WaiterState.FAILURE, reason: reason }];
+                }
+                return [3, 3];
+            case 3: return [2, { state: WaiterState.RETRY, reason: reason }];
         }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.ProcessingJobStatus;
-            };
-            if (returnComparator() === "Stopped") {
-                return { state: WaiterState.SUCCESS, reason };
-            }
+    });
+}); };
+export var waitForProcessingJobCompletedOrStopped = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults;
+    return __generator(this, function (_a) {
+        serviceDefaults = { minDelay: 60, maxDelay: 120 };
+        return [2, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+    });
+}); };
+export var waitUntilProcessingJobCompletedOrStopped = function (params, input) { return __awaiter(void 0, void 0, void 0, function () {
+    var serviceDefaults, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                serviceDefaults = { minDelay: 60, maxDelay: 120 };
+                return [4, createWaiter(__assign(__assign({}, serviceDefaults), params), input, checkState)];
+            case 1:
+                result = _a.sent();
+                return [2, checkExceptions(result)];
         }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.ProcessingJobStatus;
-            };
-            if (returnComparator() === "Failed") {
-                return { state: WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-        if (exception.name && exception.name == "ValidationException") {
-            return { state: WaiterState.FAILURE, reason };
-        }
-    }
-    return { state: WaiterState.RETRY, reason };
-};
-export const waitForProcessingJobCompletedOrStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-};
-export const waitUntilProcessingJobCompletedOrStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 120 };
-    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return checkExceptions(result);
-};
+    });
+}); };