@aws-sdk/client-neptune-graph 3.696.0 → 3.709.0

package/dist-cjs/index.js

@@ -23,6 +23,7 @@ var src_exports = {};
 __export(src_exports, {
   AccessDeniedException: () => AccessDeniedException,
   BlankNodeHandling: () => BlankNodeHandling,
+  CancelExportTaskCommand: () => CancelExportTaskCommand,
   CancelImportTaskCommand: () => CancelImportTaskCommand,
   CancelQueryCommand: () => CancelQueryCommand,
   ConflictException: () => ConflictException,
@@ -37,7 +38,10 @@ __export(src_exports, {
   ExecuteQueryCommand: () => ExecuteQueryCommand,
   ExecuteQueryOutputFilterSensitiveLog: () => ExecuteQueryOutputFilterSensitiveLog,
   ExplainMode: () => ExplainMode,
+  ExportFormat: () => ExportFormat,
+  ExportTaskStatus: () => ExportTaskStatus,
   Format: () => Format,
+  GetExportTaskCommand: () => GetExportTaskCommand,
   GetGraphCommand: () => GetGraphCommand,
   GetGraphSnapshotCommand: () => GetGraphSnapshotCommand,
   GetGraphSummaryCommand: () => GetGraphSummaryCommand,
@@ -49,15 +53,18 @@ __export(src_exports, {
   ImportOptions: () => ImportOptions,
   ImportTaskStatus: () => ImportTaskStatus,
   InternalServerException: () => InternalServerException,
+  ListExportTasksCommand: () => ListExportTasksCommand,
   ListGraphSnapshotsCommand: () => ListGraphSnapshotsCommand,
   ListGraphsCommand: () => ListGraphsCommand,
   ListImportTasksCommand: () => ListImportTasksCommand,
   ListPrivateGraphEndpointsCommand: () => ListPrivateGraphEndpointsCommand,
   ListQueriesCommand: () => ListQueriesCommand,
   ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  MultiValueHandlingType: () => MultiValueHandlingType,
   NeptuneGraph: () => NeptuneGraph,
   NeptuneGraphClient: () => NeptuneGraphClient,
   NeptuneGraphServiceException: () => NeptuneGraphServiceException,
+  ParquetType: () => ParquetType,
   PlanCacheType: () => PlanCacheType,
   PrivateGraphEndpointStatus: () => PrivateGraphEndpointStatus,
   QueryLanguage: () => QueryLanguage,
@@ -68,6 +75,7 @@ __export(src_exports, {
   RestoreGraphFromSnapshotCommand: () => RestoreGraphFromSnapshotCommand,
   ServiceQuotaExceededException: () => ServiceQuotaExceededException,
   SnapshotStatus: () => SnapshotStatus,
+  StartExportTaskCommand: () => StartExportTaskCommand,
   StartImportTaskCommand: () => StartImportTaskCommand,
   TagResourceCommand: () => TagResourceCommand,
   ThrottlingException: () => ThrottlingException,
@@ -78,10 +86,13 @@ __export(src_exports, {
   ValidationException: () => ValidationException,
   ValidationExceptionReason: () => ValidationExceptionReason,
   __Client: () => import_smithy_client.Client,
+  paginateListExportTasks: () => paginateListExportTasks,
   paginateListGraphSnapshots: () => paginateListGraphSnapshots,
   paginateListGraphs: () => paginateListGraphs,
   paginateListImportTasks: () => paginateListImportTasks,
   paginateListPrivateGraphEndpoints: () => paginateListPrivateGraphEndpoints,
+  waitForExportTaskCancelled: () => waitForExportTaskCancelled,
+  waitForExportTaskSuccessful: () => waitForExportTaskSuccessful,
   waitForGraphAvailable: () => waitForGraphAvailable,
   waitForGraphDeleted: () => waitForGraphDeleted,
   waitForGraphSnapshotAvailable: () => waitForGraphSnapshotAvailable,
@@ -90,6 +101,8 @@ __export(src_exports, {
   waitForImportTaskSuccessful: () => waitForImportTaskSuccessful,
   waitForPrivateGraphEndpointAvailable: () => waitForPrivateGraphEndpointAvailable,
   waitForPrivateGraphEndpointDeleted: () => waitForPrivateGraphEndpointDeleted,
+  waitUntilExportTaskCancelled: () => waitUntilExportTaskCancelled,
+  waitUntilExportTaskSuccessful: () => waitUntilExportTaskSuccessful,
   waitUntilGraphAvailable: () => waitUntilGraphAvailable,
   waitUntilGraphDeleted: () => waitUntilGraphDeleted,
   waitUntilGraphSnapshotAvailable: () => waitUntilGraphSnapshotAvailable,
@@ -241,7 +254,7 @@ var NeptuneGraphClient = _NeptuneGraphClient;
 // src/NeptuneGraph.ts
 
 
-// src/commands/CancelImportTaskCommand.ts
+// src/commands/CancelExportTaskCommand.ts
 
 var import_middleware_serde = require("@smithy/middleware-serde");
 
@@ -482,15 +495,33 @@ var SnapshotStatus = {
   DELETING: "DELETING",
   FAILED: "FAILED"
 };
+var ExportFormat = {
+  CSV: "CSV",
+  PARQUET: "PARQUET"
+};
+var ParquetType = {
+  COLUMNAR: "COLUMNAR"
+};
+var ExportTaskStatus = {
+  CANCELLED: "CANCELLED",
+  CANCELLING: "CANCELLING",
+  DELETED: "DELETED",
+  EXPORTING: "EXPORTING",
+  FAILED: "FAILED",
+  INITIALIZING: "INITIALIZING",
+  SUCCEEDED: "SUCCEEDED"
+};
 var Format = {
   CSV: "CSV",
   NTRIPLES: "NTRIPLES",
-  OPEN_CYPHER: "OPEN_CYPHER"
+  OPEN_CYPHER: "OPEN_CYPHER",
+  PARQUET: "PARQUET"
 };
 var ImportTaskStatus = {
   ANALYZING_DATA: "ANALYZING_DATA",
   CANCELLED: "CANCELLED",
   CANCELLING: "CANCELLING",
+  DELETED: "DELETED",
   EXPORTING: "EXPORTING",
   FAILED: "FAILED",
   IMPORTING: "IMPORTING",
@@ -510,11 +541,24 @@ var ImportOptions;
     return visitor._(value.$unknown[0], value.$unknown[1]);
   }, "visit");
 })(ImportOptions || (ImportOptions = {}));
+var MultiValueHandlingType = {
+  PICK_FIRST: "PICK_FIRST",
+  TO_LIST: "TO_LIST"
+};
 var ExecuteQueryOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj
 }), "ExecuteQueryOutputFilterSensitiveLog");
 
 // src/protocols/Aws_restJson1.ts
+var se_CancelExportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(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();
+}, "se_CancelExportTaskCommand");
 var se_CancelImportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -604,6 +648,7 @@ var se_CreateGraphUsingImportTaskCommand = /* @__PURE__ */ __name(async (input,
       kmsKeyIdentifier: [],
       maxProvisionedMemory: [],
       minProvisionedMemory: [],
+      parquetType: [],
       publicConnectivity: [],
       replicaCount: [],
       roleArn: [],
@@ -697,6 +742,15 @@ var se_ExecuteQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_ExecuteQueryCommand");
+var se_GetExportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(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();
+}, "se_GetExportTaskCommand");
 var se_GetGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -782,6 +836,18 @@ var se_GetQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("GET").h(headers).b(body);
   return b.build();
 }, "se_GetQueryCommand");
+var se_ListExportTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/exporttasks");
+  const query = (0, import_smithy_client.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();
+}, "se_ListExportTasksCommand");
 var se_ListGraphsCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -904,6 +970,28 @@ var se_RestoreGraphFromSnapshotCommand = /* @__PURE__ */ __name(async (input, co
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_RestoreGraphFromSnapshotCommand");
+var se_StartExportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/exporttasks");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      destination: [],
+      exportFilter: (_) => (0, import_smithy_client._json)(_),
+      format: [],
+      graphIdentifier: [],
+      kmsKeyIdentifier: [],
+      parquetType: [],
+      roleArn: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartExportTaskCommand");
 var se_StartImportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -918,6 +1006,7 @@ var se_StartImportTaskCommand = /* @__PURE__ */ __name(async (input, context) =>
       failOnError: [],
       format: [],
       importOptions: (_) => (0, import_smithy_client._json)(_),
+      parquetType: [],
       roleArn: [],
       source: []
     })
@@ -971,6 +1060,28 @@ var se_UpdateGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("PATCH").h(headers).b(body);
   return b.build();
 }, "se_UpdateGraphCommand");
+var de_CancelExportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    destination: import_smithy_client.expectString,
+    format: import_smithy_client.expectString,
+    graphId: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    parquetType: import_smithy_client.expectString,
+    roleArn: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    taskId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CancelExportTaskCommand");
 var de_CancelImportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -982,6 +1093,7 @@ var de_CancelImportTaskCommand = /* @__PURE__ */ __name(async (output, context)
   const doc = (0, import_smithy_client.take)(data, {
     format: import_smithy_client.expectString,
     graphId: import_smithy_client.expectString,
+    parquetType: import_smithy_client.expectString,
     roleArn: import_smithy_client.expectString,
     source: import_smithy_client.expectString,
     status: import_smithy_client.expectString,
@@ -1060,6 +1172,7 @@ var de_CreateGraphUsingImportTaskCommand = /* @__PURE__ */ __name(async (output,
     format: import_smithy_client.expectString,
     graphId: import_smithy_client.expectString,
     importOptions: (_) => (0, import_smithy_client._json)((0, import_core2.awsExpectUnion)(_)),
+    parquetType: import_smithy_client.expectString,
     roleArn: import_smithy_client.expectString,
     source: import_smithy_client.expectString,
     status: import_smithy_client.expectString,
@@ -1162,6 +1275,30 @@ var de_ExecuteQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
   contents.payload = data;
   return contents;
 }, "de_ExecuteQueryCommand");
+var de_GetExportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    destination: import_smithy_client.expectString,
+    exportFilter: import_smithy_client._json,
+    exportTaskDetails: (_) => de_ExportTaskDetails(_, context),
+    format: import_smithy_client.expectString,
+    graphId: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    parquetType: import_smithy_client.expectString,
+    roleArn: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    taskId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetExportTaskCommand");
 var de_GetGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1240,6 +1377,7 @@ var de_GetImportTaskCommand = /* @__PURE__ */ __name(async (output, context) =>
     graphId: import_smithy_client.expectString,
     importOptions: (_) => (0, import_smithy_client._json)((0, import_core2.awsExpectUnion)(_)),
     importTaskDetails: (_) => de_ImportTaskDetails(_, context),
+    parquetType: import_smithy_client.expectString,
     roleArn: import_smithy_client.expectString,
     source: import_smithy_client.expectString,
     status: import_smithy_client.expectString,
@@ -1284,6 +1422,21 @@ var de_GetQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
   Object.assign(contents, doc);
   return contents;
 }, "de_GetQueryCommand");
+var de_ListExportTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    tasks: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListExportTasksCommand");
 var de_ListGraphsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1428,6 +1581,29 @@ var de_RestoreGraphFromSnapshotCommand = /* @__PURE__ */ __name(async (output, c
   Object.assign(contents, doc);
   return contents;
 }, "de_RestoreGraphFromSnapshotCommand");
+var de_StartExportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    destination: import_smithy_client.expectString,
+    exportFilter: import_smithy_client._json,
+    format: import_smithy_client.expectString,
+    graphId: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    parquetType: import_smithy_client.expectString,
+    roleArn: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    taskId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartExportTaskCommand");
 var de_StartImportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 201 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -1440,6 +1616,7 @@ var de_StartImportTaskCommand = /* @__PURE__ */ __name(async (output, context) =
     format: import_smithy_client.expectString,
     graphId: import_smithy_client.expectString,
     importOptions: (_) => (0, import_smithy_client._json)((0, import_core2.awsExpectUnion)(_)),
+    parquetType: import_smithy_client.expectString,
     roleArn: import_smithy_client.expectString,
     source: import_smithy_client.expectString,
     status: import_smithy_client.expectString,
@@ -1660,6 +1837,15 @@ var se_DocumentValuedMap = /* @__PURE__ */ __name((input, context) => {
 var se_Document = /* @__PURE__ */ __name((input, context) => {
   return input;
 }, "se_Document");
+var de_ExportTaskDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    numEdgesWritten: import_smithy_client.expectLong,
+    numVerticesWritten: import_smithy_client.expectLong,
+    progressPercentage: import_smithy_client.expectInt32,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    timeElapsedSeconds: import_smithy_client.expectLong
+  });
+}, "de_ExportTaskDetails");
 var de_GraphSnapshotSummary = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     arn: import_smithy_client.expectString,
@@ -1704,7 +1890,24 @@ var _s = "state";
 var _sS = "skipSnapshot";
 var _tK = "tagKeys";
 
+// src/commands/CancelExportTaskCommand.ts
+var _CancelExportTaskCommand = class _CancelExportTaskCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `ControlPlane` }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonNeptuneGraph", "CancelExportTask", {}).n("NeptuneGraphClient", "CancelExportTaskCommand").f(void 0, void 0).ser(se_CancelExportTaskCommand).de(de_CancelExportTaskCommand).build() {
+};
+__name(_CancelExportTaskCommand, "CancelExportTaskCommand");
+var CancelExportTaskCommand = _CancelExportTaskCommand;
+
 // src/commands/CancelImportTaskCommand.ts
+
+
+
 var _CancelImportTaskCommand = class _CancelImportTaskCommand extends import_smithy_client.Command.classBuilder().ep({
   ...commonParams,
   ApiType: { type: "staticContextParams", value: `ControlPlane` }
@@ -1871,6 +2074,23 @@ var _ExecuteQueryCommand = class _ExecuteQueryCommand extends import_smithy_clie
 __name(_ExecuteQueryCommand, "ExecuteQueryCommand");
 var ExecuteQueryCommand = _ExecuteQueryCommand;
 
+// src/commands/GetExportTaskCommand.ts
+
+
+
+var _GetExportTaskCommand = class _GetExportTaskCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `ControlPlane` }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonNeptuneGraph", "GetExportTask", {}).n("NeptuneGraphClient", "GetExportTaskCommand").f(void 0, void 0).ser(se_GetExportTaskCommand).de(de_GetExportTaskCommand).build() {
+};
+__name(_GetExportTaskCommand, "GetExportTaskCommand");
+var GetExportTaskCommand = _GetExportTaskCommand;
+
 // src/commands/GetGraphCommand.ts
 
 
@@ -1973,6 +2193,23 @@ var _GetQueryCommand = class _GetQueryCommand extends import_smithy_client.Comma
 __name(_GetQueryCommand, "GetQueryCommand");
 var GetQueryCommand = _GetQueryCommand;
 
+// src/commands/ListExportTasksCommand.ts
+
+
+
+var _ListExportTasksCommand = class _ListExportTasksCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `ControlPlane` }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonNeptuneGraph", "ListExportTasks", {}).n("NeptuneGraphClient", "ListExportTasksCommand").f(void 0, void 0).ser(se_ListExportTasksCommand).de(de_ListExportTasksCommand).build() {
+};
+__name(_ListExportTasksCommand, "ListExportTasksCommand");
+var ListExportTasksCommand = _ListExportTasksCommand;
+
 // src/commands/ListGraphsCommand.ts
 
 
@@ -2109,6 +2346,23 @@ var _RestoreGraphFromSnapshotCommand = class _RestoreGraphFromSnapshotCommand ex
 __name(_RestoreGraphFromSnapshotCommand, "RestoreGraphFromSnapshotCommand");
 var RestoreGraphFromSnapshotCommand = _RestoreGraphFromSnapshotCommand;
 
+// src/commands/StartExportTaskCommand.ts
+
+
+
+var _StartExportTaskCommand = class _StartExportTaskCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `ControlPlane` }
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonNeptuneGraph", "StartExportTask", {}).n("NeptuneGraphClient", "StartExportTaskCommand").f(void 0, void 0).ser(se_StartExportTaskCommand).de(de_StartExportTaskCommand).build() {
+};
+__name(_StartExportTaskCommand, "StartExportTaskCommand");
+var StartExportTaskCommand = _StartExportTaskCommand;
+
 // src/commands/StartImportTaskCommand.ts
 
 
@@ -2179,6 +2433,7 @@ var UpdateGraphCommand = _UpdateGraphCommand;
 
 // src/NeptuneGraph.ts
 var commands = {
+  CancelExportTaskCommand,
   CancelImportTaskCommand,
   CancelQueryCommand,
   CreateGraphCommand,
@@ -2189,12 +2444,14 @@ var commands = {
   DeleteGraphSnapshotCommand,
   DeletePrivateGraphEndpointCommand,
   ExecuteQueryCommand,
+  GetExportTaskCommand,
   GetGraphCommand,
   GetGraphSnapshotCommand,
   GetGraphSummaryCommand,
   GetImportTaskCommand,
   GetPrivateGraphEndpointCommand,
   GetQueryCommand,
+  ListExportTasksCommand,
   ListGraphsCommand,
   ListGraphSnapshotsCommand,
   ListImportTasksCommand,
@@ -2203,6 +2460,7 @@ var commands = {
   ListTagsForResourceCommand,
   ResetGraphCommand,
   RestoreGraphFromSnapshotCommand,
+  StartExportTaskCommand,
   StartImportTaskCommand,
   TagResourceCommand,
   UntagResourceCommand,
@@ -2214,6 +2472,10 @@ __name(_NeptuneGraph, "NeptuneGraph");
 var NeptuneGraph = _NeptuneGraph;
 (0, import_smithy_client.createAggregatedClient)(commands, NeptuneGraph);
 
+// src/pagination/ListExportTasksPaginator.ts
+
+var paginateListExportTasks = (0, import_core.createPaginator)(NeptuneGraphClient, ListExportTasksCommand, "nextToken", "nextToken", "maxResults");
+
 // src/pagination/ListGraphSnapshotsPaginator.ts
 
 var paginateListGraphSnapshots = (0, import_core.createPaginator)(NeptuneGraphClient, ListGraphSnapshotsCommand, "nextToken", "nextToken", "maxResults");
@@ -2230,9 +2492,107 @@ var paginateListImportTasks = (0, import_core.createPaginator)(NeptuneGraphClien
 
 var paginateListPrivateGraphEndpoints = (0, import_core.createPaginator)(NeptuneGraphClient, ListPrivateGraphEndpointsCommand, "nextToken", "nextToken", "maxResults");
 
-// src/waiters/waitForGraphAvailable.ts
+// src/waiters/waitForExportTaskCancelled.ts
 var import_util_waiter = require("@smithy/util-waiter");
 var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetExportTaskCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status != "CANCELLING" && result.status != "CANCELLED";
+      }, "returnComparator");
+      if (returnComparator() == true) {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "CANCELLED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForExportTaskCancelled = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForExportTaskCancelled");
+var waitUntilExportTaskCancelled = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilExportTaskCancelled");
+
+// src/waiters/waitForExportTaskSuccessful.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetExportTaskCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "CANCELLING") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "CANCELLED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "SUCCEEDED") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForExportTaskSuccessful = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForExportTaskSuccessful");
+var waitUntilExportTaskSuccessful = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilExportTaskSuccessful");
+
+// src/waiters/waitForGraphAvailable.ts
+
+var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetGraphCommand(input));
@@ -2271,17 +2631,17 @@ var checkState = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForGraphAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
 }, "waitForGraphAvailable");
 var waitUntilGraphAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilGraphAvailable");
 
 // src/waiters/waitForGraphDeleted.ts
 
-var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetGraphCommand(input));
@@ -2305,17 +2665,17 @@ var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForGraphDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
 }, "waitForGraphDeleted");
 var waitUntilGraphDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilGraphDeleted");
 
 // src/waiters/waitForGraphSnapshotAvailable.ts
 
-var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState5 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetGraphSnapshotCommand(input));
@@ -2354,17 +2714,17 @@ var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForGraphSnapshotAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
 }, "waitForGraphSnapshotAvailable");
 var waitUntilGraphSnapshotAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilGraphSnapshotAvailable");
 
 // src/waiters/waitForGraphSnapshotDeleted.ts
 
-var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState6 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetGraphSnapshotCommand(input));
@@ -2388,17 +2748,17 @@ var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForGraphSnapshotDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
 }, "waitForGraphSnapshotDeleted");
 var waitUntilGraphSnapshotDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilGraphSnapshotDeleted");
 
 // src/waiters/waitForImportTaskCancelled.ts
 
-var checkState5 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState7 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetImportTaskCommand(input));
@@ -2428,17 +2788,17 @@ var checkState5 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForImportTaskCancelled = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
 }, "waitForImportTaskCancelled");
 var waitUntilImportTaskCancelled = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilImportTaskCancelled");
 
 // src/waiters/waitForImportTaskSuccessful.ts
 
-var checkState6 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState8 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetImportTaskCommand(input));
@@ -2495,17 +2855,17 @@ var checkState6 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForImportTaskSuccessful = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
 }, "waitForImportTaskSuccessful");
 var waitUntilImportTaskSuccessful = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilImportTaskSuccessful");
 
 // src/waiters/waitForPrivateGraphEndpointAvailable.ts
 
-var checkState7 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState9 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetPrivateGraphEndpointCommand(input));
@@ -2544,17 +2904,17 @@ var checkState7 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForPrivateGraphEndpointAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState9);
 }, "waitForPrivateGraphEndpointAvailable");
 var waitUntilPrivateGraphEndpointAvailable = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState9);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilPrivateGraphEndpointAvailable");
 
 // src/waiters/waitForPrivateGraphEndpointDeleted.ts
 
-var checkState8 = /* @__PURE__ */ __name(async (client, input) => {
+var checkState10 = /* @__PURE__ */ __name(async (client, input) => {
   let reason;
   try {
     const result = await client.send(new GetPrivateGraphEndpointCommand(input));
@@ -2578,11 +2938,11 @@ var checkState8 = /* @__PURE__ */ __name(async (client, input) => {
 }, "checkState");
 var waitForPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState10);
 }, "waitForPrivateGraphEndpointDeleted");
 var waitUntilPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params, input) => {
   const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState10);
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilPrivateGraphEndpointDeleted");
 // Annotate the CommonJS export names for ESM import in node:
@@ -2593,6 +2953,7 @@ var waitUntilPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params,
   NeptuneGraphClient,
   NeptuneGraph,
   $Command,
+  CancelExportTaskCommand,
   CancelImportTaskCommand,
   CancelQueryCommand,
   CreateGraphCommand,
@@ -2603,12 +2964,14 @@ var waitUntilPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params,
   DeleteGraphSnapshotCommand,
   DeletePrivateGraphEndpointCommand,
   ExecuteQueryCommand,
+  GetExportTaskCommand,
   GetGraphCommand,
   GetGraphSnapshotCommand,
   GetGraphSummaryCommand,
   GetImportTaskCommand,
   GetPrivateGraphEndpointCommand,
   GetQueryCommand,
+  ListExportTasksCommand,
   ListGraphSnapshotsCommand,
   ListGraphsCommand,
   ListImportTasksCommand,
@@ -2617,14 +2980,20 @@ var waitUntilPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params,
   ListTagsForResourceCommand,
   ResetGraphCommand,
   RestoreGraphFromSnapshotCommand,
+  StartExportTaskCommand,
   StartImportTaskCommand,
   TagResourceCommand,
   UntagResourceCommand,
   UpdateGraphCommand,
+  paginateListExportTasks,
   paginateListGraphSnapshots,
   paginateListGraphs,
   paginateListImportTasks,
   paginateListPrivateGraphEndpoints,
+  waitForExportTaskCancelled,
+  waitUntilExportTaskCancelled,
+  waitForExportTaskSuccessful,
+  waitUntilExportTaskSuccessful,
   waitForGraphAvailable,
   waitUntilGraphAvailable,
   waitForGraphDeleted,
@@ -2661,10 +3030,14 @@ var waitUntilPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params,
   QueryStateInput,
   PrivateGraphEndpointStatus,
   SnapshotStatus,
+  ExportFormat,
+  ParquetType,
+  ExportTaskStatus,
   Format,
   ImportTaskStatus,
   BlankNodeHandling,
   ImportOptions,
+  MultiValueHandlingType,
   ExecuteQueryOutputFilterSensitiveLog
 });