@aws-sdk/client-neptune-graph 3.693.0 → 3.699.0

package/dist-es/NeptuneGraph.js

@@ -1,4 +1,5 @@
 import { createAggregatedClient } from "@smithy/smithy-client";
+import { CancelExportTaskCommand, } from "./commands/CancelExportTaskCommand";
 import { CancelImportTaskCommand, } from "./commands/CancelImportTaskCommand";
 import { CancelQueryCommand } from "./commands/CancelQueryCommand";
 import { CreateGraphCommand } from "./commands/CreateGraphCommand";
@@ -9,12 +10,14 @@ import { DeleteGraphCommand } from "./commands/DeleteGraphCommand";
 import { DeleteGraphSnapshotCommand, } from "./commands/DeleteGraphSnapshotCommand";
 import { DeletePrivateGraphEndpointCommand, } from "./commands/DeletePrivateGraphEndpointCommand";
 import { ExecuteQueryCommand, } from "./commands/ExecuteQueryCommand";
+import { GetExportTaskCommand, } from "./commands/GetExportTaskCommand";
 import { GetGraphCommand } from "./commands/GetGraphCommand";
 import { GetGraphSnapshotCommand, } from "./commands/GetGraphSnapshotCommand";
 import { GetGraphSummaryCommand, } from "./commands/GetGraphSummaryCommand";
 import { GetImportTaskCommand, } from "./commands/GetImportTaskCommand";
 import { GetPrivateGraphEndpointCommand, } from "./commands/GetPrivateGraphEndpointCommand";
 import { GetQueryCommand } from "./commands/GetQueryCommand";
+import { ListExportTasksCommand, } from "./commands/ListExportTasksCommand";
 import { ListGraphsCommand } from "./commands/ListGraphsCommand";
 import { ListGraphSnapshotsCommand, } from "./commands/ListGraphSnapshotsCommand";
 import { ListImportTasksCommand, } from "./commands/ListImportTasksCommand";
@@ -23,12 +26,14 @@ import { ListQueriesCommand } from "./commands/ListQueriesCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { ResetGraphCommand } from "./commands/ResetGraphCommand";
 import { RestoreGraphFromSnapshotCommand, } from "./commands/RestoreGraphFromSnapshotCommand";
+import { StartExportTaskCommand, } from "./commands/StartExportTaskCommand";
 import { StartImportTaskCommand, } from "./commands/StartImportTaskCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateGraphCommand } from "./commands/UpdateGraphCommand";
 import { NeptuneGraphClient } from "./NeptuneGraphClient";
 const commands = {
+    CancelExportTaskCommand,
     CancelImportTaskCommand,
     CancelQueryCommand,
     CreateGraphCommand,
@@ -39,12 +44,14 @@ const commands = {
     DeleteGraphSnapshotCommand,
     DeletePrivateGraphEndpointCommand,
     ExecuteQueryCommand,
+    GetExportTaskCommand,
     GetGraphCommand,
     GetGraphSnapshotCommand,
     GetGraphSummaryCommand,
     GetImportTaskCommand,
     GetPrivateGraphEndpointCommand,
     GetQueryCommand,
+    ListExportTasksCommand,
     ListGraphsCommand,
     ListGraphSnapshotsCommand,
     ListImportTasksCommand,
@@ -53,6 +60,7 @@ const commands = {
     ListTagsForResourceCommand,
     ResetGraphCommand,
     RestoreGraphFromSnapshotCommand,
+    StartExportTaskCommand,
     StartImportTaskCommand,
     TagResourceCommand,
     UntagResourceCommand,

package/dist-es/commands/CancelExportTaskCommand.js

@@ -0,0 +1,25 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_CancelExportTaskCommand, se_CancelExportTaskCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CancelExportTaskCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "CancelExportTask", {})
+    .n("NeptuneGraphClient", "CancelExportTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_CancelExportTaskCommand)
+    .de(de_CancelExportTaskCommand)
+    .build() {
+}

package/dist-es/commands/GetExportTaskCommand.js

@@ -0,0 +1,25 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_GetExportTaskCommand, se_GetExportTaskCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetExportTaskCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "GetExportTask", {})
+    .n("NeptuneGraphClient", "GetExportTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_GetExportTaskCommand)
+    .de(de_GetExportTaskCommand)
+    .build() {
+}

package/dist-es/commands/ListExportTasksCommand.js

@@ -0,0 +1,25 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_ListExportTasksCommand, se_ListExportTasksCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListExportTasksCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "ListExportTasks", {})
+    .n("NeptuneGraphClient", "ListExportTasksCommand")
+    .f(void 0, void 0)
+    .ser(se_ListExportTasksCommand)
+    .de(de_ListExportTasksCommand)
+    .build() {
+}

package/dist-es/commands/StartExportTaskCommand.js

@@ -0,0 +1,25 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { de_StartExportTaskCommand, se_StartExportTaskCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class StartExportTaskCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+    ApiType: { type: "staticContextParams", value: `ControlPlane` },
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonNeptuneGraph", "StartExportTask", {})
+    .n("NeptuneGraphClient", "StartExportTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_StartExportTaskCommand)
+    .de(de_StartExportTaskCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -1,3 +1,4 @@
+export * from "./CancelExportTaskCommand";
 export * from "./CancelImportTaskCommand";
 export * from "./CancelQueryCommand";
 export * from "./CreateGraphCommand";
@@ -8,12 +9,14 @@ export * from "./DeleteGraphCommand";
 export * from "./DeleteGraphSnapshotCommand";
 export * from "./DeletePrivateGraphEndpointCommand";
 export * from "./ExecuteQueryCommand";
+export * from "./GetExportTaskCommand";
 export * from "./GetGraphCommand";
 export * from "./GetGraphSnapshotCommand";
 export * from "./GetGraphSummaryCommand";
 export * from "./GetImportTaskCommand";
 export * from "./GetPrivateGraphEndpointCommand";
 export * from "./GetQueryCommand";
+export * from "./ListExportTasksCommand";
 export * from "./ListGraphSnapshotsCommand";
 export * from "./ListGraphsCommand";
 export * from "./ListImportTasksCommand";
@@ -22,6 +25,7 @@ export * from "./ListQueriesCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./ResetGraphCommand";
 export * from "./RestoreGraphFromSnapshotCommand";
+export * from "./StartExportTaskCommand";
 export * from "./StartImportTaskCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";

package/dist-es/models/models_0.js

@@ -174,15 +174,33 @@ export const SnapshotStatus = {
     DELETING: "DELETING",
     FAILED: "FAILED",
 };
+export const ExportFormat = {
+    CSV: "CSV",
+    PARQUET: "PARQUET",
+};
+export const ParquetType = {
+    COLUMNAR: "COLUMNAR",
+};
+export const ExportTaskStatus = {
+    CANCELLED: "CANCELLED",
+    CANCELLING: "CANCELLING",
+    DELETED: "DELETED",
+    EXPORTING: "EXPORTING",
+    FAILED: "FAILED",
+    INITIALIZING: "INITIALIZING",
+    SUCCEEDED: "SUCCEEDED",
+};
 export const Format = {
     CSV: "CSV",
     NTRIPLES: "NTRIPLES",
     OPEN_CYPHER: "OPEN_CYPHER",
+    PARQUET: "PARQUET",
 };
 export const ImportTaskStatus = {
     ANALYZING_DATA: "ANALYZING_DATA",
     CANCELLED: "CANCELLED",
     CANCELLING: "CANCELLING",
+    DELETED: "DELETED",
     EXPORTING: "EXPORTING",
     FAILED: "FAILED",
     IMPORTING: "IMPORTING",
@@ -202,6 +220,10 @@ export var ImportOptions;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(ImportOptions || (ImportOptions = {}));
+export const MultiValueHandlingType = {
+    PICK_FIRST: "PICK_FIRST",
+    TO_LIST: "TO_LIST",
+};
 export const ExecuteQueryOutputFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/pagination/ListExportTasksPaginator.js

@@ -0,0 +1,4 @@
+import { createPaginator } from "@smithy/core";
+import { ListExportTasksCommand, } from "../commands/ListExportTasksCommand";
+import { NeptuneGraphClient } from "../NeptuneGraphClient";
+export const paginateListExportTasks = createPaginator(NeptuneGraphClient, ListExportTasksCommand, "nextToken", "nextToken", "maxResults");

package/dist-es/pagination/index.js

@@ -1,4 +1,5 @@
 export * from "./Interfaces";
+export * from "./ListExportTasksPaginator";
 export * from "./ListGraphSnapshotsPaginator";
 export * from "./ListGraphsPaginator";
 export * from "./ListImportTasksPaginator";

package/dist-es/protocols/Aws_restJson1.js

@@ -4,6 +4,15 @@ import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
 import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, isSerializableHeaderValue, map, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, take, withBaseException, } from "@smithy/smithy-client";
 import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, UnprocessableException, ValidationException, } from "../models/models_0";
 import { NeptuneGraphServiceException as __BaseException } from "../models/NeptuneGraphServiceException";
+export const se_CancelExportTaskCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/exporttasks/{taskIdentifier}");
+    b.p("taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
+    let body;
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
 export const se_CancelImportTaskCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -88,6 +97,7 @@ export const se_CreateGraphUsingImportTaskCommand = async (input, context) => {
         kmsKeyIdentifier: [],
         maxProvisionedMemory: [],
         minProvisionedMemory: [],
+        parquetType: [],
         publicConnectivity: [],
         replicaCount: [],
         roleArn: [],
@@ -176,6 +186,15 @@ export const se_ExecuteQueryCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_GetExportTaskCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/exporttasks/{taskIdentifier}");
+    b.p("taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
+    let body;
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
 export const se_GetGraphCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -261,6 +280,18 @@ export const se_GetQueryCommand = async (input, context) => {
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_ListExportTasksCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/exporttasks");
+    const query = map({
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    });
+    let body;
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_ListGraphsCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -379,6 +410,26 @@ export const se_RestoreGraphFromSnapshotCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_StartExportTaskCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/exporttasks");
+    let body;
+    body = JSON.stringify(take(input, {
+        destination: [],
+        exportFilter: (_) => _json(_),
+        format: [],
+        graphIdentifier: [],
+        kmsKeyIdentifier: [],
+        parquetType: [],
+        roleArn: [],
+        tags: (_) => _json(_),
+    }));
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_StartImportTaskCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -392,6 +443,7 @@ export const se_StartImportTaskCommand = async (input, context) => {
         failOnError: [],
         format: [],
         importOptions: (_) => _json(_),
+        parquetType: [],
         roleArn: [],
         source: [],
     }));
@@ -440,6 +492,28 @@ export const se_UpdateGraphCommand = async (input, context) => {
     b.m("PATCH").h(headers).b(body);
     return b.build();
 };
+export const de_CancelExportTaskCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        destination: __expectString,
+        format: __expectString,
+        graphId: __expectString,
+        kmsKeyIdentifier: __expectString,
+        parquetType: __expectString,
+        roleArn: __expectString,
+        status: __expectString,
+        statusReason: __expectString,
+        taskId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_CancelImportTaskCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -451,6 +525,7 @@ export const de_CancelImportTaskCommand = async (output, context) => {
     const doc = take(data, {
         format: __expectString,
         graphId: __expectString,
+        parquetType: __expectString,
         roleArn: __expectString,
         source: __expectString,
         status: __expectString,
@@ -529,6 +604,7 @@ export const de_CreateGraphUsingImportTaskCommand = async (output, context) => {
         format: __expectString,
         graphId: __expectString,
         importOptions: (_) => _json(__expectUnion(_)),
+        parquetType: __expectString,
         roleArn: __expectString,
         source: __expectString,
         status: __expectString,
@@ -631,6 +707,30 @@ export const de_ExecuteQueryCommand = async (output, context) => {
     contents.payload = data;
     return contents;
 };
+export const de_GetExportTaskCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        destination: __expectString,
+        exportFilter: _json,
+        exportTaskDetails: (_) => de_ExportTaskDetails(_, context),
+        format: __expectString,
+        graphId: __expectString,
+        kmsKeyIdentifier: __expectString,
+        parquetType: __expectString,
+        roleArn: __expectString,
+        status: __expectString,
+        statusReason: __expectString,
+        taskId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_GetGraphCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -709,6 +809,7 @@ export const de_GetImportTaskCommand = async (output, context) => {
         graphId: __expectString,
         importOptions: (_) => _json(__expectUnion(_)),
         importTaskDetails: (_) => de_ImportTaskDetails(_, context),
+        parquetType: __expectString,
         roleArn: __expectString,
         source: __expectString,
         status: __expectString,
@@ -753,6 +854,21 @@ export const de_GetQueryCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_ListExportTasksCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        tasks: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_ListGraphsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -897,6 +1013,29 @@ export const de_RestoreGraphFromSnapshotCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_StartExportTaskCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        destination: __expectString,
+        exportFilter: _json,
+        format: __expectString,
+        graphId: __expectString,
+        kmsKeyIdentifier: __expectString,
+        parquetType: __expectString,
+        roleArn: __expectString,
+        status: __expectString,
+        statusReason: __expectString,
+        taskId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_StartImportTaskCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -909,6 +1048,7 @@ export const de_StartImportTaskCommand = async (output, context) => {
         format: __expectString,
         graphId: __expectString,
         importOptions: (_) => _json(__expectUnion(_)),
+        parquetType: __expectString,
         roleArn: __expectString,
         source: __expectString,
         status: __expectString,
@@ -1129,6 +1269,15 @@ const se_DocumentValuedMap = (input, context) => {
 const se_Document = (input, context) => {
     return input;
 };
+const de_ExportTaskDetails = (output, context) => {
+    return take(output, {
+        numEdgesWritten: __expectLong,
+        numVerticesWritten: __expectLong,
+        progressPercentage: __expectInt32,
+        startTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        timeElapsedSeconds: __expectLong,
+    });
+};
 const de_GraphSnapshotSummary = (output, context) => {
     return take(output, {
         arn: __expectString,

package/dist-es/waiters/index.js

@@ -1,3 +1,5 @@
+export * from "./waitForExportTaskCancelled";
+export * from "./waitForExportTaskSuccessful";
 export * from "./waitForGraphAvailable";
 export * from "./waitForGraphDeleted";
 export * from "./waitForGraphSnapshotAvailable";

package/dist-es/waiters/waitForExportTaskCancelled.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetExportTaskCommand } from "../commands/GetExportTaskCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetExportTaskCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status != "CANCELLING" && result.status != "CANCELLED";
+            };
+            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 waitForExportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilExportTaskCancelled = async (params, input) => {
+    const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForExportTaskSuccessful.js

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