@aws-sdk/client-neptune-graph 3.975.0 → 3.978.0

package/dist-cjs/index.js

@@ -1611,52 +1611,12 @@ class UpdateGraphCommand extends smithyClient.Command
     .build() {
 }
 
-const commands = {
-    CancelExportTaskCommand,
-    CancelImportTaskCommand,
-    CancelQueryCommand,
-    CreateGraphCommand,
-    CreateGraphSnapshotCommand,
-    CreateGraphUsingImportTaskCommand,
-    CreatePrivateGraphEndpointCommand,
-    DeleteGraphCommand,
-    DeleteGraphSnapshotCommand,
-    DeletePrivateGraphEndpointCommand,
-    ExecuteQueryCommand,
-    GetExportTaskCommand,
-    GetGraphCommand,
-    GetGraphSnapshotCommand,
-    GetGraphSummaryCommand,
-    GetImportTaskCommand,
-    GetPrivateGraphEndpointCommand,
-    GetQueryCommand,
-    ListExportTasksCommand,
-    ListGraphsCommand,
-    ListGraphSnapshotsCommand,
-    ListImportTasksCommand,
-    ListPrivateGraphEndpointsCommand,
-    ListQueriesCommand,
-    ListTagsForResourceCommand,
-    ResetGraphCommand,
-    RestoreGraphFromSnapshotCommand,
-    StartExportTaskCommand,
-    StartGraphCommand,
-    StartImportTaskCommand,
-    StopGraphCommand,
-    TagResourceCommand,
-    UntagResourceCommand,
-    UpdateGraphCommand,
-};
-class NeptuneGraph extends NeptuneGraphClient {
-}
-smithyClient.createAggregatedClient(commands, NeptuneGraph);
-
 const paginateListExportTasks = core.createPaginator(NeptuneGraphClient, ListExportTasksCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListGraphs = core.createPaginator(NeptuneGraphClient, ListGraphsCommand, "nextToken", "nextToken", "maxResults");
-
 const paginateListGraphSnapshots = core.createPaginator(NeptuneGraphClient, ListGraphSnapshotsCommand, "nextToken", "nextToken", "maxResults");
 
+const paginateListGraphs = core.createPaginator(NeptuneGraphClient, ListGraphsCommand, "nextToken", "nextToken", "maxResults");
+
 const paginateListImportTasks = core.createPaginator(NeptuneGraphClient, ListImportTasksCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListPrivateGraphEndpoints = core.createPaginator(NeptuneGraphClient, ListPrivateGraphEndpointsCommand, "nextToken", "nextToken", "maxResults");
@@ -1668,9 +1628,9 @@ const checkState$a = async (client, input) => {
         reason = result;
         try {
             const returnComparator = () => {
-                return result.status;
+                return ((result.status != "CANCELLING") && (result.status != "CANCELLED"));
             };
-            if (returnComparator() === "CANCELLING") {
+            if (returnComparator() == true) {
                 return { state: utilWaiter.WaiterState.FAILURE, reason };
             }
         }
@@ -1680,24 +1640,6 @@ const checkState$a = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "SUCCEEDED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
@@ -1708,12 +1650,12 @@ const checkState$a = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForExportTaskSuccessful = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+const waitForExportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
 };
-const waitUntilExportTaskSuccessful = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+const waitUntilExportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$a);
     return utilWaiter.checkExceptions(result);
 };
@@ -1725,9 +1667,9 @@ const checkState$9 = async (client, input) => {
         reason = result;
         try {
             const returnComparator = () => {
-                return ((result.status != "CANCELLING") && (result.status != "CANCELLED"));
+                return result.status;
             };
-            if (returnComparator() == true) {
+            if (returnComparator() === "CANCELLING") {
                 return { state: utilWaiter.WaiterState.FAILURE, reason };
             }
         }
@@ -1737,6 +1679,24 @@ const checkState$9 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "SUCCEEDED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
@@ -1747,12 +1707,12 @@ const checkState$9 = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForExportTaskCancelled = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+const waitForExportTaskSuccessful = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
 };
-const waitUntilExportTaskCancelled = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+const waitUntilExportTaskSuccessful = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
     return utilWaiter.checkExceptions(result);
 };
@@ -1839,45 +1799,6 @@ const waitUntilGraphDeleted = async (params, input) => {
 };
 
 const checkState$6 = async (client, input) => {
-    let reason;
-    try {
-        let result = await client.send(new GetGraphCommand(input));
-        reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "STOPPED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return (result.status != "STOPPING");
-            };
-            if (returnComparator() == true) {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-    }
-    catch (exception) {
-        reason = exception;
-    }
-    return { state: utilWaiter.WaiterState.RETRY, reason };
-};
-const waitForGraphStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
-};
-const waitUntilGraphStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
-    return utilWaiter.checkExceptions(result);
-};
-
-const checkState$5 = async (client, input) => {
     let reason;
     try {
         let result = await client.send(new GetGraphSnapshotCommand(input));
@@ -1917,15 +1838,15 @@ const checkState$5 = async (client, input) => {
 };
 const waitForGraphSnapshotAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
 };
 const waitUntilGraphSnapshotAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
     return utilWaiter.checkExceptions(result);
 };
 
-const checkState$4 = async (client, input) => {
+const checkState$5 = async (client, input) => {
     let reason;
     try {
         let result = await client.send(new GetGraphSnapshotCommand(input));
@@ -1950,51 +1871,63 @@ const checkState$4 = async (client, input) => {
 };
 const waitForGraphSnapshotDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilGraphSnapshotDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
     return utilWaiter.checkExceptions(result);
 };
 
-const checkState$3 = async (client, input) => {
+const checkState$4 = async (client, input) => {
     let reason;
     try {
-        let result = await client.send(new GetImportTaskCommand(input));
+        let result = await client.send(new GetGraphCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
-            if (returnComparator() === "CANCELLING") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
-            }
-        }
-        catch (e) { }
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "CANCELLED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            if (returnComparator() === "STOPPED") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.status;
+                return (result.status != "STOPPING");
             };
-            if (returnComparator() === "ROLLING_BACK") {
+            if (returnComparator() == true) {
                 return { state: utilWaiter.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForGraphStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+};
+const waitUntilGraphStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 20, maxDelay: 1800 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$3 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetImportTaskCommand(input));
+        reason = result;
         try {
             const returnComparator = () => {
-                return result.status;
+                return ((result.status != "CANCELLING") && (result.status != "CANCELLED"));
             };
-            if (returnComparator() === "FAILED") {
+            if (returnComparator() == true) {
                 return { state: utilWaiter.WaiterState.FAILURE, reason };
             }
         }
@@ -2003,7 +1936,7 @@ const checkState$3 = async (client, input) => {
             const returnComparator = () => {
                 return result.status;
             };
-            if (returnComparator() === "SUCCEEDED") {
+            if (returnComparator() === "CANCELLED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
@@ -2014,12 +1947,12 @@ const checkState$3 = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForImportTaskSuccessful = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+const waitForImportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
-const waitUntilImportTaskSuccessful = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+const waitUntilImportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
     return utilWaiter.checkExceptions(result);
 };
@@ -2031,9 +1964,9 @@ const checkState$2 = async (client, input) => {
         reason = result;
         try {
             const returnComparator = () => {
-                return ((result.status != "CANCELLING") && (result.status != "CANCELLED"));
+                return result.status;
             };
-            if (returnComparator() == true) {
+            if (returnComparator() === "CANCELLING") {
                 return { state: utilWaiter.WaiterState.FAILURE, reason };
             }
         }
@@ -2043,6 +1976,33 @@ const checkState$2 = async (client, input) => {
                 return result.status;
             };
             if (returnComparator() === "CANCELLED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "ROLLING_BACK") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "SUCCEEDED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
@@ -2053,12 +2013,12 @@ const checkState$2 = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForImportTaskCancelled = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+const waitForImportTaskSuccessful = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
-const waitUntilImportTaskCancelled = async (params, input) => {
-    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+const waitUntilImportTaskSuccessful = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
     return utilWaiter.checkExceptions(result);
 };
@@ -2144,6 +2104,66 @@ const waitUntilPrivateGraphEndpointDeleted = async (params, input) => {
     return utilWaiter.checkExceptions(result);
 };
 
+const commands = {
+    CancelExportTaskCommand,
+    CancelImportTaskCommand,
+    CancelQueryCommand,
+    CreateGraphCommand,
+    CreateGraphSnapshotCommand,
+    CreateGraphUsingImportTaskCommand,
+    CreatePrivateGraphEndpointCommand,
+    DeleteGraphCommand,
+    DeleteGraphSnapshotCommand,
+    DeletePrivateGraphEndpointCommand,
+    ExecuteQueryCommand,
+    GetExportTaskCommand,
+    GetGraphCommand,
+    GetGraphSnapshotCommand,
+    GetGraphSummaryCommand,
+    GetImportTaskCommand,
+    GetPrivateGraphEndpointCommand,
+    GetQueryCommand,
+    ListExportTasksCommand,
+    ListGraphsCommand,
+    ListGraphSnapshotsCommand,
+    ListImportTasksCommand,
+    ListPrivateGraphEndpointsCommand,
+    ListQueriesCommand,
+    ListTagsForResourceCommand,
+    ResetGraphCommand,
+    RestoreGraphFromSnapshotCommand,
+    StartExportTaskCommand,
+    StartGraphCommand,
+    StartImportTaskCommand,
+    StopGraphCommand,
+    TagResourceCommand,
+    UntagResourceCommand,
+    UpdateGraphCommand,
+};
+const paginators = {
+    paginateListExportTasks,
+    paginateListGraphs,
+    paginateListGraphSnapshots,
+    paginateListImportTasks,
+    paginateListPrivateGraphEndpoints,
+};
+const waiters = {
+    waitUntilExportTaskSuccessful,
+    waitUntilExportTaskCancelled,
+    waitUntilGraphAvailable,
+    waitUntilGraphDeleted,
+    waitUntilGraphStopped,
+    waitUntilGraphSnapshotAvailable,
+    waitUntilGraphSnapshotDeleted,
+    waitUntilImportTaskSuccessful,
+    waitUntilImportTaskCancelled,
+    waitUntilPrivateGraphEndpointAvailable,
+    waitUntilPrivateGraphEndpointDeleted,
+};
+class NeptuneGraph extends NeptuneGraphClient {
+}
+smithyClient.createAggregatedClient(commands, NeptuneGraph, { paginators, waiters });
+
 const ValidationExceptionReason = {
     BAD_REQUEST: "BAD_REQUEST",
     CONSTRAINT_VIOLATION: "CONSTRAINT_VIOLATION",

package/dist-es/NeptuneGraph.js

@@ -34,6 +34,22 @@ import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateGraphCommand } from "./commands/UpdateGraphCommand";
 import { NeptuneGraphClient } from "./NeptuneGraphClient";
+import { paginateListExportTasks } from "./pagination/ListExportTasksPaginator";
+import { paginateListGraphSnapshots } from "./pagination/ListGraphSnapshotsPaginator";
+import { paginateListGraphs } from "./pagination/ListGraphsPaginator";
+import { paginateListImportTasks } from "./pagination/ListImportTasksPaginator";
+import { paginateListPrivateGraphEndpoints } from "./pagination/ListPrivateGraphEndpointsPaginator";
+import { waitUntilExportTaskCancelled } from "./waiters/waitForExportTaskCancelled";
+import { waitUntilExportTaskSuccessful } from "./waiters/waitForExportTaskSuccessful";
+import { waitUntilGraphAvailable } from "./waiters/waitForGraphAvailable";
+import { waitUntilGraphDeleted } from "./waiters/waitForGraphDeleted";
+import { waitUntilGraphSnapshotAvailable } from "./waiters/waitForGraphSnapshotAvailable";
+import { waitUntilGraphSnapshotDeleted } from "./waiters/waitForGraphSnapshotDeleted";
+import { waitUntilGraphStopped } from "./waiters/waitForGraphStopped";
+import { waitUntilImportTaskCancelled } from "./waiters/waitForImportTaskCancelled";
+import { waitUntilImportTaskSuccessful } from "./waiters/waitForImportTaskSuccessful";
+import { waitUntilPrivateGraphEndpointAvailable } from "./waiters/waitForPrivateGraphEndpointAvailable";
+import { waitUntilPrivateGraphEndpointDeleted } from "./waiters/waitForPrivateGraphEndpointDeleted";
 const commands = {
     CancelExportTaskCommand,
     CancelImportTaskCommand,
@@ -70,6 +86,26 @@ const commands = {
     UntagResourceCommand,
     UpdateGraphCommand,
 };
+const paginators = {
+    paginateListExportTasks,
+    paginateListGraphs,
+    paginateListGraphSnapshots,
+    paginateListImportTasks,
+    paginateListPrivateGraphEndpoints,
+};
+const waiters = {
+    waitUntilExportTaskSuccessful,
+    waitUntilExportTaskCancelled,
+    waitUntilGraphAvailable,
+    waitUntilGraphDeleted,
+    waitUntilGraphStopped,
+    waitUntilGraphSnapshotAvailable,
+    waitUntilGraphSnapshotDeleted,
+    waitUntilImportTaskSuccessful,
+    waitUntilImportTaskCancelled,
+    waitUntilPrivateGraphEndpointAvailable,
+    waitUntilPrivateGraphEndpointDeleted,
+};
 export class NeptuneGraph extends NeptuneGraphClient {
 }
-createAggregatedClient(commands, NeptuneGraph);
+createAggregatedClient(commands, NeptuneGraph, { paginators, waiters });

package/dist-types/NeptuneGraph.d.ts

@@ -1,4 +1,5 @@
-import type { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
+import type { HttpHandlerOptions as __HttpHandlerOptions, PaginationConfiguration, Paginator, WaiterConfiguration } from "@smithy/types";
+import type { WaiterResult } from "@smithy/util-waiter";
 import { CancelExportTaskCommandInput, CancelExportTaskCommandOutput } from "./commands/CancelExportTaskCommand";
 import { CancelImportTaskCommandInput, CancelImportTaskCommandOutput } from "./commands/CancelImportTaskCommand";
 import { CancelQueryCommandInput, CancelQueryCommandOutput } from "./commands/CancelQueryCommand";
@@ -243,6 +244,107 @@ export interface NeptuneGraph {
     updateGraph(args: UpdateGraphCommandInput, options?: __HttpHandlerOptions): Promise<UpdateGraphCommandOutput>;
     updateGraph(args: UpdateGraphCommandInput, cb: (err: any, data?: UpdateGraphCommandOutput) => void): void;
     updateGraph(args: UpdateGraphCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateGraphCommandOutput) => void): void;
+    /**
+     * @see {@link ListExportTasksCommand}
+     * @param args - command input.
+     * @param paginationConfig - optional pagination config.
+     * @returns AsyncIterable of {@link ListExportTasksCommandOutput}.
+     */
+    paginateListExportTasks(args?: ListExportTasksCommandInput, paginationConfig?: Omit<PaginationConfiguration, "client">): Paginator<ListExportTasksCommandOutput>;
+    /**
+     * @see {@link ListGraphsCommand}
+     * @param args - command input.
+     * @param paginationConfig - optional pagination config.
+     * @returns AsyncIterable of {@link ListGraphsCommandOutput}.
+     */
+    paginateListGraphs(args?: ListGraphsCommandInput, paginationConfig?: Omit<PaginationConfiguration, "client">): Paginator<ListGraphsCommandOutput>;
+    /**
+     * @see {@link ListGraphSnapshotsCommand}
+     * @param args - command input.
+     * @param paginationConfig - optional pagination config.
+     * @returns AsyncIterable of {@link ListGraphSnapshotsCommandOutput}.
+     */
+    paginateListGraphSnapshots(args?: ListGraphSnapshotsCommandInput, paginationConfig?: Omit<PaginationConfiguration, "client">): Paginator<ListGraphSnapshotsCommandOutput>;
+    /**
+     * @see {@link ListImportTasksCommand}
+     * @param args - command input.
+     * @param paginationConfig - optional pagination config.
+     * @returns AsyncIterable of {@link ListImportTasksCommandOutput}.
+     */
+    paginateListImportTasks(args?: ListImportTasksCommandInput, paginationConfig?: Omit<PaginationConfiguration, "client">): Paginator<ListImportTasksCommandOutput>;
+    /**
+     * @see {@link ListPrivateGraphEndpointsCommand}
+     * @param args - command input.
+     * @param paginationConfig - optional pagination config.
+     * @returns AsyncIterable of {@link ListPrivateGraphEndpointsCommandOutput}.
+     */
+    paginateListPrivateGraphEndpoints(args: ListPrivateGraphEndpointsCommandInput, paginationConfig?: Omit<PaginationConfiguration, "client">): Paginator<ListPrivateGraphEndpointsCommandOutput>;
+    /**
+     * @see {@link GetExportTaskCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilExportTaskSuccessful(args: GetExportTaskCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetExportTaskCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilExportTaskCancelled(args: GetExportTaskCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetGraphCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilGraphAvailable(args: GetGraphCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetGraphCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilGraphDeleted(args: GetGraphCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetGraphCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilGraphStopped(args: GetGraphCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetGraphSnapshotCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilGraphSnapshotAvailable(args: GetGraphSnapshotCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetGraphSnapshotCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilGraphSnapshotDeleted(args: GetGraphSnapshotCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetImportTaskCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilImportTaskSuccessful(args: GetImportTaskCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetImportTaskCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilImportTaskCancelled(args: GetImportTaskCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetPrivateGraphEndpointCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilPrivateGraphEndpointAvailable(args: GetPrivateGraphEndpointCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
+    /**
+     * @see {@link GetPrivateGraphEndpointCommand}
+     * @param args - command input.
+     * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
+     */
+    waitUntilPrivateGraphEndpointDeleted(args: GetPrivateGraphEndpointCommandInput, waiterConfig: number | Omit<WaiterConfiguration<NeptuneGraph>, "client">): Promise<WaiterResult>;
 }
 /**
  * <p>Neptune Analytics is a new analytics database engine for Amazon Neptune that helps customers get to insights faster by quickly processing large amounts of graph data, invoking popular graph analytic algorithms in low-latency queries, and getting analytics results in seconds.</p>

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

@@ -1,4 +1,10 @@
-import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
+import {
+  HttpHandlerOptions as __HttpHandlerOptions,
+  PaginationConfiguration,
+  Paginator,
+  WaiterConfiguration,
+} from "@smithy/types";
+import { WaiterResult } from "@smithy/util-waiter";
 import {
   CancelExportTaskCommandInput,
   CancelExportTaskCommandOutput,
@@ -583,6 +589,140 @@ export interface NeptuneGraph {
     options: __HttpHandlerOptions,
     cb: (err: any, data?: UpdateGraphCommandOutput) => void
   ): void;
+  paginateListExportTasks(
+    args?: ListExportTasksCommandInput,
+    paginationConfig?: Pick<
+      PaginationConfiguration,
+      Exclude<keyof PaginationConfiguration, "client">
+    >
+  ): Paginator<ListExportTasksCommandOutput>;
+  paginateListGraphs(
+    args?: ListGraphsCommandInput,
+    paginationConfig?: Pick<
+      PaginationConfiguration,
+      Exclude<keyof PaginationConfiguration, "client">
+    >
+  ): Paginator<ListGraphsCommandOutput>;
+  paginateListGraphSnapshots(
+    args?: ListGraphSnapshotsCommandInput,
+    paginationConfig?: Pick<
+      PaginationConfiguration,
+      Exclude<keyof PaginationConfiguration, "client">
+    >
+  ): Paginator<ListGraphSnapshotsCommandOutput>;
+  paginateListImportTasks(
+    args?: ListImportTasksCommandInput,
+    paginationConfig?: Pick<
+      PaginationConfiguration,
+      Exclude<keyof PaginationConfiguration, "client">
+    >
+  ): Paginator<ListImportTasksCommandOutput>;
+  paginateListPrivateGraphEndpoints(
+    args: ListPrivateGraphEndpointsCommandInput,
+    paginationConfig?: Pick<
+      PaginationConfiguration,
+      Exclude<keyof PaginationConfiguration, "client">
+    >
+  ): Paginator<ListPrivateGraphEndpointsCommandOutput>;
+  waitUntilExportTaskSuccessful(
+    args: GetExportTaskCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilExportTaskCancelled(
+    args: GetExportTaskCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilGraphAvailable(
+    args: GetGraphCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilGraphDeleted(
+    args: GetGraphCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilGraphStopped(
+    args: GetGraphCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilGraphSnapshotAvailable(
+    args: GetGraphSnapshotCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilGraphSnapshotDeleted(
+    args: GetGraphSnapshotCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilImportTaskSuccessful(
+    args: GetImportTaskCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilImportTaskCancelled(
+    args: GetImportTaskCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilPrivateGraphEndpointAvailable(
+    args: GetPrivateGraphEndpointCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
+  waitUntilPrivateGraphEndpointDeleted(
+    args: GetPrivateGraphEndpointCommandInput,
+    waiterConfig:
+      | number
+      | Pick<
+          WaiterConfiguration<NeptuneGraph>,
+          Exclude<keyof WaiterConfiguration<NeptuneGraph>, "client">
+        >
+  ): Promise<WaiterResult>;
 }
 export declare class NeptuneGraph
   extends NeptuneGraphClient

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.975.0",
+  "version": "3.978.0",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
     "build:cjs": "node ../../scripts/compilation/inline client-neptune-graph",
@@ -21,38 +21,38 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "5.2.0",
     "@aws-crypto/sha256-js": "5.2.0",
-    "@aws-sdk/core": "^3.973.1",
-    "@aws-sdk/credential-provider-node": "^3.972.1",
-    "@aws-sdk/middleware-host-header": "^3.972.1",
-    "@aws-sdk/middleware-logger": "^3.972.1",
-    "@aws-sdk/middleware-recursion-detection": "^3.972.1",
-    "@aws-sdk/middleware-user-agent": "^3.972.2",
-    "@aws-sdk/region-config-resolver": "^3.972.1",
-    "@aws-sdk/types": "^3.973.0",
+    "@aws-sdk/core": "^3.973.4",
+    "@aws-sdk/credential-provider-node": "^3.972.2",
+    "@aws-sdk/middleware-host-header": "^3.972.2",
+    "@aws-sdk/middleware-logger": "^3.972.2",
+    "@aws-sdk/middleware-recursion-detection": "^3.972.2",
+    "@aws-sdk/middleware-user-agent": "^3.972.4",
+    "@aws-sdk/region-config-resolver": "^3.972.2",
+    "@aws-sdk/types": "^3.973.1",
     "@aws-sdk/util-endpoints": "3.972.0",
-    "@aws-sdk/util-user-agent-browser": "^3.972.1",
-    "@aws-sdk/util-user-agent-node": "^3.972.1",
+    "@aws-sdk/util-user-agent-browser": "^3.972.2",
+    "@aws-sdk/util-user-agent-node": "^3.972.2",
     "@smithy/config-resolver": "^4.4.6",
-    "@smithy/core": "^3.21.1",
+    "@smithy/core": "^3.22.0",
     "@smithy/fetch-http-handler": "^5.3.9",
     "@smithy/hash-node": "^4.2.8",
     "@smithy/invalid-dependency": "^4.2.8",
     "@smithy/middleware-content-length": "^4.2.8",
-    "@smithy/middleware-endpoint": "^4.4.11",
-    "@smithy/middleware-retry": "^4.4.27",
+    "@smithy/middleware-endpoint": "^4.4.12",
+    "@smithy/middleware-retry": "^4.4.29",
     "@smithy/middleware-serde": "^4.2.9",
     "@smithy/middleware-stack": "^4.2.8",
     "@smithy/node-config-provider": "^4.3.8",
     "@smithy/node-http-handler": "^4.4.8",
     "@smithy/protocol-http": "^5.3.8",
-    "@smithy/smithy-client": "^4.10.12",
+    "@smithy/smithy-client": "^4.11.1",
     "@smithy/types": "^4.12.0",
     "@smithy/url-parser": "^4.2.8",
     "@smithy/util-base64": "^4.3.0",
     "@smithy/util-body-length-browser": "^4.2.0",
     "@smithy/util-body-length-node": "^4.2.1",
-    "@smithy/util-defaults-mode-browser": "^4.3.26",
-    "@smithy/util-defaults-mode-node": "^4.2.29",
+    "@smithy/util-defaults-mode-browser": "^4.3.28",
+    "@smithy/util-defaults-mode-node": "^4.2.31",
     "@smithy/util-endpoints": "^3.2.8",
     "@smithy/util-middleware": "^4.2.8",
     "@smithy/util-retry": "^4.2.8",