@aws-sdk/client-neptune-graph 3.477.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/pagination/ListGraphSnapshotsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListGraphSnapshots = void 0;
+const core_1 = require("@smithy/core");
 const ListGraphSnapshotsCommand_1 = require("../commands/ListGraphSnapshotsCommand");
 const NeptuneGraphClient_1 = require("../NeptuneGraphClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListGraphSnapshotsCommand_1.ListGraphSnapshotsCommand(input), ...args);
-};
-async function* paginateListGraphSnapshots(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof NeptuneGraphClient_1.NeptuneGraphClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListGraphSnapshots = paginateListGraphSnapshots;
+exports.paginateListGraphSnapshots = (0, core_1.createPaginator)(NeptuneGraphClient_1.NeptuneGraphClient, ListGraphSnapshotsCommand_1.ListGraphSnapshotsCommand, "nextToken", "nextToken", "maxResults");

package/dist-cjs/pagination/ListGraphsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListGraphs = void 0;
+const core_1 = require("@smithy/core");
 const ListGraphsCommand_1 = require("../commands/ListGraphsCommand");
 const NeptuneGraphClient_1 = require("../NeptuneGraphClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListGraphsCommand_1.ListGraphsCommand(input), ...args);
-};
-async function* paginateListGraphs(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof NeptuneGraphClient_1.NeptuneGraphClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListGraphs = paginateListGraphs;
+exports.paginateListGraphs = (0, core_1.createPaginator)(NeptuneGraphClient_1.NeptuneGraphClient, ListGraphsCommand_1.ListGraphsCommand, "nextToken", "nextToken", "maxResults");

package/dist-cjs/pagination/ListImportTasksPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListImportTasks = void 0;
+const core_1 = require("@smithy/core");
 const ListImportTasksCommand_1 = require("../commands/ListImportTasksCommand");
 const NeptuneGraphClient_1 = require("../NeptuneGraphClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListImportTasksCommand_1.ListImportTasksCommand(input), ...args);
-};
-async function* paginateListImportTasks(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof NeptuneGraphClient_1.NeptuneGraphClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListImportTasks = paginateListImportTasks;
+exports.paginateListImportTasks = (0, core_1.createPaginator)(NeptuneGraphClient_1.NeptuneGraphClient, ListImportTasksCommand_1.ListImportTasksCommand, "nextToken", "nextToken", "maxResults");

package/dist-cjs/pagination/ListPrivateGraphEndpointsPaginator.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.paginateListPrivateGraphEndpoints = void 0;
+const core_1 = require("@smithy/core");
 const ListPrivateGraphEndpointsCommand_1 = require("../commands/ListPrivateGraphEndpointsCommand");
 const NeptuneGraphClient_1 = require("../NeptuneGraphClient");
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListPrivateGraphEndpointsCommand_1.ListPrivateGraphEndpointsCommand(input), ...args);
-};
-async function* paginateListPrivateGraphEndpoints(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof NeptuneGraphClient_1.NeptuneGraphClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
-exports.paginateListPrivateGraphEndpoints = paginateListPrivateGraphEndpoints;
+exports.paginateListPrivateGraphEndpoints = (0, core_1.createPaginator)(NeptuneGraphClient_1.NeptuneGraphClient, ListPrivateGraphEndpointsCommand_1.ListPrivateGraphEndpointsCommand, "nextToken", "nextToken", "maxResults");

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/pagination/ListGraphSnapshotsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListGraphSnapshotsCommand, } from "../commands/ListGraphSnapshotsCommand";
 import { NeptuneGraphClient } from "../NeptuneGraphClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListGraphSnapshotsCommand(input), ...args);
-};
-export async function* paginateListGraphSnapshots(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof NeptuneGraphClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListGraphSnapshots = createPaginator(NeptuneGraphClient, ListGraphSnapshotsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/ListGraphsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListGraphsCommand } from "../commands/ListGraphsCommand";
 import { NeptuneGraphClient } from "../NeptuneGraphClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListGraphsCommand(input), ...args);
-};
-export async function* paginateListGraphs(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof NeptuneGraphClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListGraphs = createPaginator(NeptuneGraphClient, ListGraphsCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/ListImportTasksPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListImportTasksCommand, } from "../commands/ListImportTasksCommand";
 import { NeptuneGraphClient } from "../NeptuneGraphClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListImportTasksCommand(input), ...args);
-};
-export async function* paginateListImportTasks(config, input, ...additionalArguments) {
-    let token = config.startingToken || undefined;
-    let hasNext = true;
-    let page;
-    while (hasNext) {
-        input.nextToken = token;
-        input["maxResults"] = config.pageSize;
-        if (config.client instanceof NeptuneGraphClient) {
-            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
-        }
-        else {
-            throw new Error("Invalid client, expected NeptuneGraph | NeptuneGraphClient");
-        }
-        yield page;
-        const prevToken = token;
-        token = page.nextToken;
-        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
-    }
-    return undefined;
-}
+export const paginateListImportTasks = createPaginator(NeptuneGraphClient, ListImportTasksCommand, "nextToken", "nextToken", "maxResults");