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

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;

package/dist-cjs/waiters/waitForPrivateGraphEndpointAvailable.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilPrivateGraphEndpointAvailable = exports.waitForPrivateGraphEndpointAvailable = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetPrivateGraphEndpointCommand_1 = require("../commands/GetPrivateGraphEndpointCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetPrivateGraphEndpointCommand_1.GetPrivateGraphEndpointCommand(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 waitForPrivateGraphEndpointAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForPrivateGraphEndpointAvailable = waitForPrivateGraphEndpointAvailable;
+const waitUntilPrivateGraphEndpointAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilPrivateGraphEndpointAvailable = waitUntilPrivateGraphEndpointAvailable;

package/dist-cjs/waiters/waitForPrivateGraphEndpointDeleted.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilPrivateGraphEndpointDeleted = exports.waitForPrivateGraphEndpointDeleted = void 0;
+const util_waiter_1 = require("@smithy/util-waiter");
+const GetPrivateGraphEndpointCommand_1 = require("../commands/GetPrivateGraphEndpointCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetPrivateGraphEndpointCommand_1.GetPrivateGraphEndpointCommand(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 waitForPrivateGraphEndpointDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForPrivateGraphEndpointDeleted = waitForPrivateGraphEndpointDeleted;
+const waitUntilPrivateGraphEndpointDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilPrivateGraphEndpointDeleted = waitUntilPrivateGraphEndpointDeleted;

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

package/dist-es/waiters/waitForPrivateGraphEndpointAvailable.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetPrivateGraphEndpointCommand, } from "../commands/GetPrivateGraphEndpointCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetPrivateGraphEndpointCommand(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 waitForPrivateGraphEndpointAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilPrivateGraphEndpointAvailable = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForPrivateGraphEndpointDeleted.js

@@ -0,0 +1,34 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetPrivateGraphEndpointCommand, } from "../commands/GetPrivateGraphEndpointCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetPrivateGraphEndpointCommand(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 waitForPrivateGraphEndpointDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilPrivateGraphEndpointDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-types/index.d.ts

@@ -12,6 +12,7 @@ export { RuntimeExtension } from "./runtimeExtensions";
 export { NeptuneGraphExtensionConfiguration } from "./extensionConfiguration";
 export * from "./commands";
 export * from "./pagination";
+export * from "./waiters";
 export * from "./models";
 import "@aws-sdk/util-endpoints";
 export { NeptuneGraphServiceException } from "./models/NeptuneGraphServiceException";

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

@@ -5,6 +5,7 @@ export { RuntimeExtension } from "./runtimeExtensions";
 export { NeptuneGraphExtensionConfiguration } from "./extensionConfiguration";
 export * from "./commands";
 export * from "./pagination";
+export * from "./waiters";
 export * from "./models";
 import "@aws-sdk/util-endpoints";
 export { NeptuneGraphServiceException } from "./models/NeptuneGraphServiceException";

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

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetGraphCommandInput } from "../commands/GetGraphCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export declare const waitForGraphAvailable: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetGraphCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilGraphAvailable: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetGraphCommandInput
+) => Promise<WaiterResult>;

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetGraphCommandInput } from "../commands/GetGraphCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export declare const waitForGraphDeleted: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetGraphCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilGraphDeleted: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetGraphCommandInput
+) => Promise<WaiterResult>;

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetGraphSnapshotCommandInput } from "../commands/GetGraphSnapshotCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export declare const waitForGraphSnapshotAvailable: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetGraphSnapshotCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilGraphSnapshotAvailable: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetGraphSnapshotCommandInput
+) => Promise<WaiterResult>;

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetGraphSnapshotCommandInput } from "../commands/GetGraphSnapshotCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export declare const waitForGraphSnapshotDeleted: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetGraphSnapshotCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilGraphSnapshotDeleted: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetGraphSnapshotCommandInput
+) => Promise<WaiterResult>;

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetImportTaskCommandInput } from "../commands/GetImportTaskCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export declare const waitForImportTaskCancelled: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetImportTaskCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilImportTaskCancelled: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetImportTaskCommandInput
+) => Promise<WaiterResult>;

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetImportTaskCommandInput } from "../commands/GetImportTaskCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export declare const waitForImportTaskSuccessful: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetImportTaskCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilImportTaskSuccessful: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetImportTaskCommandInput
+) => Promise<WaiterResult>;

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetPrivateGraphEndpointCommandInput } from "../commands/GetPrivateGraphEndpointCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export declare const waitForPrivateGraphEndpointAvailable: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetPrivateGraphEndpointCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilPrivateGraphEndpointAvailable: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetPrivateGraphEndpointCommandInput
+) => Promise<WaiterResult>;

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

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetPrivateGraphEndpointCommandInput } from "../commands/GetPrivateGraphEndpointCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export declare const waitForPrivateGraphEndpointDeleted: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetPrivateGraphEndpointCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilPrivateGraphEndpointDeleted: (
+  params: WaiterConfiguration<NeptuneGraphClient>,
+  input: GetPrivateGraphEndpointCommandInput
+) => Promise<WaiterResult>;

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

@@ -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-types/waiters/waitForGraphAvailable.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetGraphCommandInput } from "../commands/GetGraphCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+/**
+ * Wait until Graph is Available
+ *  @deprecated Use waitUntilGraphAvailable instead. waitForGraphAvailable does not throw error in non-success cases.
+ */
+export declare const waitForGraphAvailable: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetGraphCommandInput) => Promise<WaiterResult>;
+/**
+ * Wait until Graph is Available
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetGraphCommand for polling.
+ */
+export declare const waitUntilGraphAvailable: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetGraphCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForGraphDeleted.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetGraphCommandInput } from "../commands/GetGraphCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+/**
+ * Wait until Graph is Deleted
+ *  @deprecated Use waitUntilGraphDeleted instead. waitForGraphDeleted does not throw error in non-success cases.
+ */
+export declare const waitForGraphDeleted: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetGraphCommandInput) => Promise<WaiterResult>;
+/**
+ * Wait until Graph is Deleted
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetGraphCommand for polling.
+ */
+export declare const waitUntilGraphDeleted: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetGraphCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForGraphSnapshotAvailable.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetGraphSnapshotCommandInput } from "../commands/GetGraphSnapshotCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+/**
+ * Wait until GraphSnapshot is Available
+ *  @deprecated Use waitUntilGraphSnapshotAvailable instead. waitForGraphSnapshotAvailable does not throw error in non-success cases.
+ */
+export declare const waitForGraphSnapshotAvailable: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetGraphSnapshotCommandInput) => Promise<WaiterResult>;
+/**
+ * Wait until GraphSnapshot is Available
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetGraphSnapshotCommand for polling.
+ */
+export declare const waitUntilGraphSnapshotAvailable: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetGraphSnapshotCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForGraphSnapshotDeleted.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetGraphSnapshotCommandInput } from "../commands/GetGraphSnapshotCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+/**
+ * Wait until GraphSnapshot is Deleted
+ *  @deprecated Use waitUntilGraphSnapshotDeleted instead. waitForGraphSnapshotDeleted does not throw error in non-success cases.
+ */
+export declare const waitForGraphSnapshotDeleted: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetGraphSnapshotCommandInput) => Promise<WaiterResult>;
+/**
+ * Wait until GraphSnapshot is Deleted
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetGraphSnapshotCommand for polling.
+ */
+export declare const waitUntilGraphSnapshotDeleted: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetGraphSnapshotCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForImportTaskCancelled.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetImportTaskCommandInput } from "../commands/GetImportTaskCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+/**
+ * Wait until Import Task is Cancelled
+ *  @deprecated Use waitUntilImportTaskCancelled instead. waitForImportTaskCancelled does not throw error in non-success cases.
+ */
+export declare const waitForImportTaskCancelled: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetImportTaskCommandInput) => Promise<WaiterResult>;
+/**
+ * Wait until Import Task is Cancelled
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetImportTaskCommand for polling.
+ */
+export declare const waitUntilImportTaskCancelled: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetImportTaskCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForImportTaskSuccessful.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetImportTaskCommandInput } from "../commands/GetImportTaskCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+/**
+ * Wait until Import Task is Successful
+ *  @deprecated Use waitUntilImportTaskSuccessful instead. waitForImportTaskSuccessful does not throw error in non-success cases.
+ */
+export declare const waitForImportTaskSuccessful: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetImportTaskCommandInput) => Promise<WaiterResult>;
+/**
+ * Wait until Import Task is Successful
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetImportTaskCommand for polling.
+ */
+export declare const waitUntilImportTaskSuccessful: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetImportTaskCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForPrivateGraphEndpointAvailable.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetPrivateGraphEndpointCommandInput } from "../commands/GetPrivateGraphEndpointCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+/**
+ * Wait until PrivateGraphEndpoint is Available
+ *  @deprecated Use waitUntilPrivateGraphEndpointAvailable instead. waitForPrivateGraphEndpointAvailable does not throw error in non-success cases.
+ */
+export declare const waitForPrivateGraphEndpointAvailable: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetPrivateGraphEndpointCommandInput) => Promise<WaiterResult>;
+/**
+ * Wait until PrivateGraphEndpoint is Available
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetPrivateGraphEndpointCommand for polling.
+ */
+export declare const waitUntilPrivateGraphEndpointAvailable: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetPrivateGraphEndpointCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForPrivateGraphEndpointDeleted.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetPrivateGraphEndpointCommandInput } from "../commands/GetPrivateGraphEndpointCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+/**
+ * Wait until PrivateGraphEndpoint is Deleted
+ *  @deprecated Use waitUntilPrivateGraphEndpointDeleted instead. waitForPrivateGraphEndpointDeleted does not throw error in non-success cases.
+ */
+export declare const waitForPrivateGraphEndpointDeleted: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetPrivateGraphEndpointCommandInput) => Promise<WaiterResult>;
+/**
+ * Wait until PrivateGraphEndpoint is Deleted
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetPrivateGraphEndpointCommand for polling.
+ */
+export declare const waitUntilPrivateGraphEndpointDeleted: (params: WaiterConfiguration<NeptuneGraphClient>, input: GetPrivateGraphEndpointCommandInput) => Promise<WaiterResult>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-neptune-graph",
   "description": "AWS SDK for JavaScript Neptune Graph Client for Node.js, Browser and React Native",
-  "version": "3.478.0",
+  "version": "3.479.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -57,6 +57,7 @@
     "@smithy/util-endpoints": "^1.0.7",
     "@smithy/util-retry": "^2.0.8",
     "@smithy/util-utf8": "^2.0.2",
+    "@smithy/util-waiter": "^2.0.15",
     "tslib": "^2.5.0"
   },
   "devDependencies": {