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

package/dist-es/pagination/ListPrivateGraphEndpointsPaginator.js

@@ -1,25 +1,4 @@
+import { createPaginator } from "@smithy/core";
 import { ListPrivateGraphEndpointsCommand, } from "../commands/ListPrivateGraphEndpointsCommand";
 import { NeptuneGraphClient } from "../NeptuneGraphClient";
-const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListPrivateGraphEndpointsCommand(input), ...args);
-};
-export 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) {
-            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 paginateListPrivateGraphEndpoints = createPaginator(NeptuneGraphClient, ListPrivateGraphEndpointsCommand, "nextToken", "nextToken", "maxResults");

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

@@ -4,4 +4,4 @@ import { NeptuneGraphPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListGraphSnapshots(config: NeptuneGraphPaginationConfiguration, input: ListGraphSnapshotsCommandInput, ...additionalArguments: any): Paginator<ListGraphSnapshotsCommandOutput>;
+export declare const paginateListGraphSnapshots: (config: NeptuneGraphPaginationConfiguration, input: ListGraphSnapshotsCommandInput, ...rest: any[]) => Paginator<ListGraphSnapshotsCommandOutput>;

package/dist-types/pagination/ListGraphsPaginator.d.ts

@@ -4,4 +4,4 @@ import { NeptuneGraphPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListGraphs(config: NeptuneGraphPaginationConfiguration, input: ListGraphsCommandInput, ...additionalArguments: any): Paginator<ListGraphsCommandOutput>;
+export declare const paginateListGraphs: (config: NeptuneGraphPaginationConfiguration, input: ListGraphsCommandInput, ...rest: any[]) => Paginator<ListGraphsCommandOutput>;

package/dist-types/pagination/ListImportTasksPaginator.d.ts

@@ -4,4 +4,4 @@ import { NeptuneGraphPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListImportTasks(config: NeptuneGraphPaginationConfiguration, input: ListImportTasksCommandInput, ...additionalArguments: any): Paginator<ListImportTasksCommandOutput>;
+export declare const paginateListImportTasks: (config: NeptuneGraphPaginationConfiguration, input: ListImportTasksCommandInput, ...rest: any[]) => Paginator<ListImportTasksCommandOutput>;

package/dist-types/pagination/ListPrivateGraphEndpointsPaginator.d.ts

@@ -4,4 +4,4 @@ import { NeptuneGraphPaginationConfiguration } from "./Interfaces";
 /**
  * @public
  */
-export declare function paginateListPrivateGraphEndpoints(config: NeptuneGraphPaginationConfiguration, input: ListPrivateGraphEndpointsCommandInput, ...additionalArguments: any): Paginator<ListPrivateGraphEndpointsCommandOutput>;
+export declare const paginateListPrivateGraphEndpoints: (config: NeptuneGraphPaginationConfiguration, input: ListPrivateGraphEndpointsCommandInput, ...rest: any[]) => Paginator<ListPrivateGraphEndpointsCommandOutput>;

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

@@ -4,8 +4,8 @@ import {
   ListGraphSnapshotsCommandOutput,
 } from "../commands/ListGraphSnapshotsCommand";
 import { NeptuneGraphPaginationConfiguration } from "./Interfaces";
-export declare function paginateListGraphSnapshots(
+export declare const paginateListGraphSnapshots: (
   config: NeptuneGraphPaginationConfiguration,
   input: ListGraphSnapshotsCommandInput,
-  ...additionalArguments: any
-): Paginator<ListGraphSnapshotsCommandOutput>;
+  ...rest: any[]
+) => Paginator<ListGraphSnapshotsCommandOutput>;

package/dist-types/ts3.4/pagination/ListGraphsPaginator.d.ts

@@ -4,8 +4,8 @@ import {
   ListGraphsCommandOutput,
 } from "../commands/ListGraphsCommand";
 import { NeptuneGraphPaginationConfiguration } from "./Interfaces";
-export declare function paginateListGraphs(
+export declare const paginateListGraphs: (
   config: NeptuneGraphPaginationConfiguration,
   input: ListGraphsCommandInput,
-  ...additionalArguments: any
-): Paginator<ListGraphsCommandOutput>;
+  ...rest: any[]
+) => Paginator<ListGraphsCommandOutput>;

package/dist-types/ts3.4/pagination/ListImportTasksPaginator.d.ts

@@ -4,8 +4,8 @@ import {
   ListImportTasksCommandOutput,
 } from "../commands/ListImportTasksCommand";
 import { NeptuneGraphPaginationConfiguration } from "./Interfaces";
-export declare function paginateListImportTasks(
+export declare const paginateListImportTasks: (
   config: NeptuneGraphPaginationConfiguration,
   input: ListImportTasksCommandInput,
-  ...additionalArguments: any
-): Paginator<ListImportTasksCommandOutput>;
+  ...rest: any[]
+) => Paginator<ListImportTasksCommandOutput>;

package/dist-types/ts3.4/pagination/ListPrivateGraphEndpointsPaginator.d.ts

@@ -4,8 +4,8 @@ import {
   ListPrivateGraphEndpointsCommandOutput,
 } from "../commands/ListPrivateGraphEndpointsCommand";
 import { NeptuneGraphPaginationConfiguration } from "./Interfaces";
-export declare function paginateListPrivateGraphEndpoints(
+export declare const paginateListPrivateGraphEndpoints: (
   config: NeptuneGraphPaginationConfiguration,
   input: ListPrivateGraphEndpointsCommandInput,
-  ...additionalArguments: any
-): Paginator<ListPrivateGraphEndpointsCommandOutput>;
+  ...rest: any[]
+) => Paginator<ListPrivateGraphEndpointsCommandOutput>;

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>;