@aws-sdk/client-neptune-graph 3.504.0 → 3.505.0

package/dist-cjs/index.js

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
   CancelImportTaskCommand: () => CancelImportTaskCommand,
+  CancelQueryCommand: () => CancelQueryCommand,
   ConflictException: () => ConflictException,
   ConflictExceptionReason: () => ConflictExceptionReason,
   CreateGraphCommand: () => CreateGraphCommand,
@@ -31,12 +33,18 @@ __export(src_exports, {
   DeleteGraphCommand: () => DeleteGraphCommand,
   DeleteGraphSnapshotCommand: () => DeleteGraphSnapshotCommand,
   DeletePrivateGraphEndpointCommand: () => DeletePrivateGraphEndpointCommand,
+  ExecuteQueryCommand: () => ExecuteQueryCommand,
+  ExecuteQueryOutputFilterSensitiveLog: () => ExecuteQueryOutputFilterSensitiveLog,
+  ExplainMode: () => ExplainMode,
   Format: () => Format,
   GetGraphCommand: () => GetGraphCommand,
   GetGraphSnapshotCommand: () => GetGraphSnapshotCommand,
+  GetGraphSummaryCommand: () => GetGraphSummaryCommand,
   GetImportTaskCommand: () => GetImportTaskCommand,
   GetPrivateGraphEndpointCommand: () => GetPrivateGraphEndpointCommand,
+  GetQueryCommand: () => GetQueryCommand,
   GraphStatus: () => GraphStatus,
+  GraphSummaryMode: () => GraphSummaryMode,
   ImportOptions: () => ImportOptions,
   ImportTaskStatus: () => ImportTaskStatus,
   InternalServerException: () => InternalServerException,
@@ -44,11 +52,16 @@ __export(src_exports, {
   ListGraphsCommand: () => ListGraphsCommand,
   ListImportTasksCommand: () => ListImportTasksCommand,
   ListPrivateGraphEndpointsCommand: () => ListPrivateGraphEndpointsCommand,
+  ListQueriesCommand: () => ListQueriesCommand,
   ListTagsForResourceCommand: () => ListTagsForResourceCommand,
   NeptuneGraph: () => NeptuneGraph,
   NeptuneGraphClient: () => NeptuneGraphClient,
   NeptuneGraphServiceException: () => NeptuneGraphServiceException,
+  PlanCacheType: () => PlanCacheType,
   PrivateGraphEndpointStatus: () => PrivateGraphEndpointStatus,
+  QueryLanguage: () => QueryLanguage,
+  QueryState: () => QueryState,
+  QueryStateInput: () => QueryStateInput,
   ResetGraphCommand: () => ResetGraphCommand,
   ResourceNotFoundException: () => ResourceNotFoundException,
   RestoreGraphFromSnapshotCommand: () => RestoreGraphFromSnapshotCommand,
@@ -56,6 +69,8 @@ __export(src_exports, {
   SnapshotStatus: () => SnapshotStatus,
   TagResourceCommand: () => TagResourceCommand,
   ThrottlingException: () => ThrottlingException,
+  UnprocessableException: () => UnprocessableException,
+  UnprocessableExceptionReason: () => UnprocessableExceptionReason,
   UntagResourceCommand: () => UntagResourceCommand,
   UpdateGraphCommand: () => UpdateGraphCommand,
   ValidationException: () => ValidationException,
@@ -183,6 +198,7 @@ var import_core = require("@aws-sdk/core");
 var import_core2 = require("@smithy/core");
 
 
+
 // src/models/NeptuneGraphServiceException.ts
 
 var _NeptuneGraphServiceException = class _NeptuneGraphServiceException extends import_smithy_client.ServiceException {
@@ -198,36 +214,23 @@ __name(_NeptuneGraphServiceException, "NeptuneGraphServiceException");
 var NeptuneGraphServiceException = _NeptuneGraphServiceException;
 
 // src/models/models_0.ts
-var ConflictExceptionReason = {
-  CONCURRENT_MODIFICATION: "CONCURRENT_MODIFICATION"
-};
-var _ConflictException = class _ConflictException extends NeptuneGraphServiceException {
+var _AccessDeniedException = class _AccessDeniedException extends NeptuneGraphServiceException {
   /**
    * @internal
    */
   constructor(opts) {
     super({
-      name: "ConflictException",
+      name: "AccessDeniedException",
       $fault: "client",
       ...opts
     });
-    this.name = "ConflictException";
+    this.name = "AccessDeniedException";
     this.$fault = "client";
-    Object.setPrototypeOf(this, _ConflictException.prototype);
-    this.reason = opts.reason;
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
   }
 };
-__name(_ConflictException, "ConflictException");
-var ConflictException = _ConflictException;
-var GraphStatus = {
-  AVAILABLE: "AVAILABLE",
-  CREATING: "CREATING",
-  DELETING: "DELETING",
-  FAILED: "FAILED",
-  RESETTING: "RESETTING",
-  SNAPSHOTTING: "SNAPSHOTTING",
-  UPDATING: "UPDATING"
-};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
 var _InternalServerException = class _InternalServerException extends NeptuneGraphServiceException {
   /**
    * @internal
@@ -246,27 +249,23 @@ var _InternalServerException = class _InternalServerException extends NeptuneGra
 };
 __name(_InternalServerException, "InternalServerException");
 var InternalServerException = _InternalServerException;
-var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends NeptuneGraphServiceException {
+var _ResourceNotFoundException = class _ResourceNotFoundException extends NeptuneGraphServiceException {
   /**
    * @internal
    */
   constructor(opts) {
     super({
-      name: "ServiceQuotaExceededException",
+      name: "ResourceNotFoundException",
       $fault: "client",
       ...opts
     });
-    this.name = "ServiceQuotaExceededException";
+    this.name = "ResourceNotFoundException";
     this.$fault = "client";
-    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
-    this.resourceId = opts.resourceId;
-    this.resourceType = opts.resourceType;
-    this.serviceCode = opts.serviceCode;
-    this.quotaCode = opts.quotaCode;
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
   }
 };
-__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
-var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
 var _ThrottlingException = class _ThrottlingException extends NeptuneGraphServiceException {
   /**
    * @internal
@@ -314,23 +313,109 @@ var _ValidationException = class _ValidationException extends NeptuneGraphServic
 };
 __name(_ValidationException, "ValidationException");
 var ValidationException = _ValidationException;
-var _ResourceNotFoundException = class _ResourceNotFoundException extends NeptuneGraphServiceException {
+var ConflictExceptionReason = {
+  CONCURRENT_MODIFICATION: "CONCURRENT_MODIFICATION"
+};
+var _ConflictException = class _ConflictException extends NeptuneGraphServiceException {
   /**
    * @internal
    */
   constructor(opts) {
     super({
-      name: "ResourceNotFoundException",
+      name: "ConflictException",
       $fault: "client",
       ...opts
     });
-    this.name = "ResourceNotFoundException";
+    this.name = "ConflictException";
     this.$fault = "client";
-    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.reason = opts.reason;
   }
 };
-__name(_ResourceNotFoundException, "ResourceNotFoundException");
-var ResourceNotFoundException = _ResourceNotFoundException;
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var ExplainMode = {
+  DETAILS: "DETAILS",
+  STATIC: "STATIC"
+};
+var QueryLanguage = {
+  OPEN_CYPHER: "OPEN_CYPHER"
+};
+var PlanCacheType = {
+  AUTO: "AUTO",
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var UnprocessableExceptionReason = {
+  INTERNAL_LIMIT_EXCEEDED: "INTERNAL_LIMIT_EXCEEDED",
+  MEMORY_LIMIT_EXCEEDED: "MEMORY_LIMIT_EXCEEDED",
+  PARTITION_FULL: "PARTITION_FULL",
+  QUERY_TIMEOUT: "QUERY_TIMEOUT",
+  STORAGE_LIMIT_EXCEEDED: "STORAGE_LIMIT_EXCEEDED"
+};
+var _UnprocessableException = class _UnprocessableException extends NeptuneGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnprocessableException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnprocessableException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnprocessableException.prototype);
+    this.reason = opts.reason;
+  }
+};
+__name(_UnprocessableException, "UnprocessableException");
+var UnprocessableException = _UnprocessableException;
+var GraphSummaryMode = {
+  BASIC: "BASIC",
+  DETAILED: "DETAILED"
+};
+var QueryState = {
+  CANCELLING: "CANCELLING",
+  RUNNING: "RUNNING",
+  WAITING: "WAITING"
+};
+var GraphStatus = {
+  AVAILABLE: "AVAILABLE",
+  CREATING: "CREATING",
+  DELETING: "DELETING",
+  FAILED: "FAILED",
+  RESETTING: "RESETTING",
+  SNAPSHOTTING: "SNAPSHOTTING",
+  UPDATING: "UPDATING"
+};
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends NeptuneGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.resourceId = opts.resourceId;
+    this.resourceType = opts.resourceType;
+    this.serviceCode = opts.serviceCode;
+    this.quotaCode = opts.quotaCode;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var QueryStateInput = {
+  ALL: "ALL",
+  CANCELLING: "CANCELLING",
+  RUNNING: "RUNNING",
+  WAITING: "WAITING"
+};
 var PrivateGraphEndpointStatus = {
   AVAILABLE: "AVAILABLE",
   CREATING: "CREATING",
@@ -367,6 +452,9 @@ var ImportOptions;
     return visitor._(value.$unknown[0], value.$unknown[1]);
   }, "visit");
 })(ImportOptions || (ImportOptions = {}));
+var ExecuteQueryOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "ExecuteQueryOutputFilterSensitiveLog");
 
 // src/protocols/Aws_restJson1.ts
 var se_CancelImportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
@@ -378,6 +466,29 @@ var se_CancelImportTaskCommand = /* @__PURE__ */ __name(async (input, context) =
   b.m("DELETE").h(headers).b(body);
   return b.build();
 }, "se_CancelImportTaskCommand");
+var se_CancelQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_g]: input[_gI]
+  });
+  b.bp("/queries/{queryId}");
+  b.p("queryId", () => input.queryId, "{queryId}", false);
+  let body;
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+    if (input.graphIdentifier === void 0) {
+      throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+    }
+    resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  b.hn(resolvedHostname);
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_CancelQueryCommand");
 var se_CreateGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core2.requestBuilder)(input, context);
   const headers = {
@@ -494,6 +605,38 @@ var se_DeletePrivateGraphEndpointCommand = /* @__PURE__ */ __name(async (input,
   b.m("DELETE").h(headers).b(body);
   return b.build();
 }, "se_DeletePrivateGraphEndpointCommand");
+var se_ExecuteQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    "content-type": "application/json",
+    [_g]: input[_gI]
+  });
+  b.bp("/queries");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      explain: [, , `explainMode`],
+      language: [],
+      planCache: [],
+      query: [, , `queryString`],
+      queryTimeoutMilliseconds: []
+    })
+  );
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+    if (input.graphIdentifier === void 0) {
+      throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+    }
+    resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  b.hn(resolvedHostname);
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ExecuteQueryCommand");
 var se_GetGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core2.requestBuilder)(input, context);
   const headers = {};
@@ -512,6 +655,31 @@ var se_GetGraphSnapshotCommand = /* @__PURE__ */ __name(async (input, context) =
   b.m("GET").h(headers).b(body);
   return b.build();
 }, "se_GetGraphSnapshotCommand");
+var se_GetGraphSummaryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_g]: input[_gI]
+  });
+  b.bp("/summary");
+  const query = (0, import_smithy_client.map)({
+    [_m]: [, input[_m]]
+  });
+  let body;
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+    if (input.graphIdentifier === void 0) {
+      throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+    }
+    resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  b.hn(resolvedHostname);
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetGraphSummaryCommand");
 var se_GetImportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core2.requestBuilder)(input, context);
   const headers = {};
@@ -531,6 +699,29 @@ var se_GetPrivateGraphEndpointCommand = /* @__PURE__ */ __name(async (input, con
   b.m("GET").h(headers).b(body);
   return b.build();
 }, "se_GetPrivateGraphEndpointCommand");
+var se_GetQueryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_g]: input[_gI]
+  });
+  b.bp("/queries/{queryId}");
+  b.p("queryId", () => input.queryId, "{queryId}", false);
+  let body;
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+    if (input.graphIdentifier === void 0) {
+      throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+    }
+    resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  b.hn(resolvedHostname);
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetQueryCommand");
 var se_ListGraphsCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core2.requestBuilder)(input, context);
   const headers = {};
@@ -581,6 +772,32 @@ var se_ListPrivateGraphEndpointsCommand = /* @__PURE__ */ __name(async (input, c
   b.m("GET").h(headers).q(query).b(body);
   return b.build();
 }, "se_ListPrivateGraphEndpointsCommand");
+var se_ListQueriesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = (0, import_smithy_client.map)({}, isSerializableHeaderValue, {
+    [_g]: input[_gI]
+  });
+  b.bp("/queries");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [(0, import_smithy_client.expectNonNull)(input.maxResults, `maxResults`) != null, () => input[_mR].toString()],
+    [_s]: [, input[_s]]
+  });
+  let body;
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "{graphIdentifier}." + resolvedHostname;
+    if (input.graphIdentifier === void 0) {
+      throw new Error("Empty value provided for input host prefix: graphIdentifier.");
+    }
+    resolvedHostname = resolvedHostname.replace("{graphIdentifier}", input.graphIdentifier);
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  b.hn(resolvedHostname);
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListQueriesCommand");
 var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core2.requestBuilder)(input, context);
   const headers = {};
@@ -726,6 +943,47 @@ var de_CancelImportTaskCommandError = /* @__PURE__ */ __name(async (output, cont
       });
   }
 }, "de_CancelImportTaskCommandError");
+var de_CancelQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CancelQueryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CancelQueryCommand");
+var de_CancelQueryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.neptunegraph#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.neptunegraph#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.neptunegraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.neptunegraph#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CancelQueryCommandError");
 var de_CreateGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 201 && output.statusCode >= 300) {
     return de_CreateGraphCommandError(output, context);
@@ -1099,6 +1357,52 @@ var de_DeletePrivateGraphEndpointCommandError = /* @__PURE__ */ __name(async (ou
       });
   }
 }, "de_DeletePrivateGraphEndpointCommandError");
+var de_ExecuteQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ExecuteQueryCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = output.body;
+  context.sdkStreamMixin(data);
+  contents.payload = data;
+  return contents;
+}, "de_ExecuteQueryCommand");
+var de_ExecuteQueryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.neptunegraph#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.neptunegraph#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.neptunegraph#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.neptunegraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnprocessableException":
+    case "com.amazonaws.neptunegraph#UnprocessableException":
+      throw await de_UnprocessableExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.neptunegraph#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ExecuteQueryCommandError");
 var de_GetGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_GetGraphCommandError(output, context);
@@ -1203,6 +1507,53 @@ var de_GetGraphSnapshotCommandError = /* @__PURE__ */ __name(async (output, cont
       });
   }
 }, "de_GetGraphSnapshotCommandError");
+var de_GetGraphSummaryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGraphSummaryCommandError(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 parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    graphSummary: import_smithy_client._json,
+    lastStatisticsComputationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    version: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGraphSummaryCommand");
+var de_GetGraphSummaryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.neptunegraph#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.neptunegraph#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.neptunegraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.neptunegraph#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetGraphSummaryCommandError");
 var de_GetImportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_GetImportTaskCommandError(output, context);
@@ -1299,6 +1650,55 @@ var de_GetPrivateGraphEndpointCommandError = /* @__PURE__ */ __name(async (outpu
       });
   }
 }, "de_GetPrivateGraphEndpointCommandError");
+var de_GetQueryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetQueryCommandError(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 parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    elapsed: import_smithy_client.expectInt32,
+    id: import_smithy_client.expectString,
+    queryString: import_smithy_client.expectString,
+    state: import_smithy_client.expectString,
+    waited: import_smithy_client.expectInt32
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetQueryCommand");
+var de_GetQueryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.neptunegraph#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.neptunegraph#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.neptunegraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.neptunegraph#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetQueryCommandError");
 var de_ListGraphsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_ListGraphsCommandError(output, context);
@@ -1468,6 +1868,48 @@ var de_ListPrivateGraphEndpointsCommandError = /* @__PURE__ */ __name(async (out
       });
   }
 }, "de_ListPrivateGraphEndpointsCommandError");
+var de_ListQueriesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListQueriesCommandError(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 parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    queries: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListQueriesCommand");
+var de_ListQueriesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.neptunegraph#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.neptunegraph#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.neptunegraph#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.neptunegraph#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListQueriesCommandError");
 var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_ListTagsForResourceCommandError(output, context);
@@ -1767,6 +2209,19 @@ var de_UpdateGraphCommandError = /* @__PURE__ */ __name(async (output, context)
   }
 }, "de_UpdateGraphCommandError");
 var throwDefaultError = (0, import_smithy_client.withBaseException)(NeptuneGraphServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
 var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
   const contents = (0, import_smithy_client.map)({});
   const data = parsedOutput.body;
@@ -1837,6 +2292,20 @@ var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, cont
   });
   return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
 }, "de_ThrottlingExceptionRes");
+var de_UnprocessableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    reason: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new UnprocessableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_UnprocessableExceptionRes");
 var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
   const contents = (0, import_smithy_client.map)({});
   const data = parsedOutput.body;
@@ -1887,9 +2356,13 @@ var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
   cfId: output.headers["x-amz-cf-id"]
 }), "deserializeMetadata");
 var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var isSerializableHeaderValue = /* @__PURE__ */ __name((value) => value !== void 0 && value !== null && value !== "" && (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) && (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0), "isSerializableHeaderValue");
+var _g = "graphidentifier";
 var _gI = "graphIdentifier";
+var _m = "mode";
 var _mR = "maxResults";
 var _nT = "nextToken";
+var _s = "state";
 var _sS = "skipSnapshot";
 var _tK = "tagKeys";
 var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
@@ -1947,6 +2420,24 @@ var _CancelImportTaskCommand = class _CancelImportTaskCommand extends import_smi
 __name(_CancelImportTaskCommand, "CancelImportTaskCommand");
 var CancelImportTaskCommand = _CancelImportTaskCommand;
 
+// src/commands/CancelQueryCommand.ts
+
+
+
+
+var _CancelQueryCommand = class _CancelQueryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `DataPlane` }
+}).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", "CancelQuery", {}).n("NeptuneGraphClient", "CancelQueryCommand").f(void 0, void 0).ser(se_CancelQueryCommand).de(de_CancelQueryCommand).build() {
+};
+__name(_CancelQueryCommand, "CancelQueryCommand");
+var CancelQueryCommand = _CancelQueryCommand;
+
 // src/commands/CreateGraphCommand.ts
 
 
@@ -2073,6 +2564,24 @@ var _DeletePrivateGraphEndpointCommand = class _DeletePrivateGraphEndpointComman
 __name(_DeletePrivateGraphEndpointCommand, "DeletePrivateGraphEndpointCommand");
 var DeletePrivateGraphEndpointCommand = _DeletePrivateGraphEndpointCommand;
 
+// src/commands/ExecuteQueryCommand.ts
+
+
+
+
+var _ExecuteQueryCommand = class _ExecuteQueryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `DataPlane` }
+}).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", "ExecuteQuery", {}).n("NeptuneGraphClient", "ExecuteQueryCommand").f(void 0, ExecuteQueryOutputFilterSensitiveLog).ser(se_ExecuteQueryCommand).de(de_ExecuteQueryCommand).build() {
+};
+__name(_ExecuteQueryCommand, "ExecuteQueryCommand");
+var ExecuteQueryCommand = _ExecuteQueryCommand;
+
 // src/commands/GetGraphCommand.ts
 
 
@@ -2109,6 +2618,24 @@ var _GetGraphSnapshotCommand = class _GetGraphSnapshotCommand extends import_smi
 __name(_GetGraphSnapshotCommand, "GetGraphSnapshotCommand");
 var GetGraphSnapshotCommand = _GetGraphSnapshotCommand;
 
+// src/commands/GetGraphSummaryCommand.ts
+
+
+
+
+var _GetGraphSummaryCommand = class _GetGraphSummaryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `DataPlane` }
+}).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", "GetGraphSummary", {}).n("NeptuneGraphClient", "GetGraphSummaryCommand").f(void 0, void 0).ser(se_GetGraphSummaryCommand).de(de_GetGraphSummaryCommand).build() {
+};
+__name(_GetGraphSummaryCommand, "GetGraphSummaryCommand");
+var GetGraphSummaryCommand = _GetGraphSummaryCommand;
+
 // src/commands/GetImportTaskCommand.ts
 
 
@@ -2145,6 +2672,24 @@ var _GetPrivateGraphEndpointCommand = class _GetPrivateGraphEndpointCommand exte
 __name(_GetPrivateGraphEndpointCommand, "GetPrivateGraphEndpointCommand");
 var GetPrivateGraphEndpointCommand = _GetPrivateGraphEndpointCommand;
 
+// src/commands/GetQueryCommand.ts
+
+
+
+
+var _GetQueryCommand = class _GetQueryCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `DataPlane` }
+}).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", "GetQuery", {}).n("NeptuneGraphClient", "GetQueryCommand").f(void 0, void 0).ser(se_GetQueryCommand).de(de_GetQueryCommand).build() {
+};
+__name(_GetQueryCommand, "GetQueryCommand");
+var GetQueryCommand = _GetQueryCommand;
+
 // src/commands/ListGraphsCommand.ts
 
 
@@ -2217,6 +2762,24 @@ var _ListPrivateGraphEndpointsCommand = class _ListPrivateGraphEndpointsCommand
 __name(_ListPrivateGraphEndpointsCommand, "ListPrivateGraphEndpointsCommand");
 var ListPrivateGraphEndpointsCommand = _ListPrivateGraphEndpointsCommand;
 
+// src/commands/ListQueriesCommand.ts
+
+
+
+
+var _ListQueriesCommand = class _ListQueriesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams,
+  ApiType: { type: "staticContextParams", value: `DataPlane` }
+}).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", "ListQueries", {}).n("NeptuneGraphClient", "ListQueriesCommand").f(void 0, void 0).ser(se_ListQueriesCommand).de(de_ListQueriesCommand).build() {
+};
+__name(_ListQueriesCommand, "ListQueriesCommand");
+var ListQueriesCommand = _ListQueriesCommand;
+
 // src/commands/ListTagsForResourceCommand.ts
 
 
@@ -2328,6 +2891,7 @@ var UpdateGraphCommand = _UpdateGraphCommand;
 // src/NeptuneGraph.ts
 var commands = {
   CancelImportTaskCommand,
+  CancelQueryCommand,
   CreateGraphCommand,
   CreateGraphSnapshotCommand,
   CreateGraphUsingImportTaskCommand,
@@ -2335,14 +2899,18 @@ var commands = {
   DeleteGraphCommand,
   DeleteGraphSnapshotCommand,
   DeletePrivateGraphEndpointCommand,
+  ExecuteQueryCommand,
   GetGraphCommand,
   GetGraphSnapshotCommand,
+  GetGraphSummaryCommand,
   GetImportTaskCommand,
   GetPrivateGraphEndpointCommand,
+  GetQueryCommand,
   ListGraphsCommand,
   ListGraphSnapshotsCommand,
   ListImportTasksCommand,
   ListPrivateGraphEndpointsCommand,
+  ListQueriesCommand,
   ListTagsForResourceCommand,
   ResetGraphCommand,
   RestoreGraphFromSnapshotCommand,
@@ -2739,6 +3307,7 @@ var import_util_endpoints = require("@aws-sdk/util-endpoints");
   NeptuneGraph,
   $Command,
   CancelImportTaskCommand,
+  CancelQueryCommand,
   CreateGraphCommand,
   CreateGraphSnapshotCommand,
   CreateGraphUsingImportTaskCommand,
@@ -2746,14 +3315,18 @@ var import_util_endpoints = require("@aws-sdk/util-endpoints");
   DeleteGraphCommand,
   DeleteGraphSnapshotCommand,
   DeletePrivateGraphEndpointCommand,
+  ExecuteQueryCommand,
   GetGraphCommand,
   GetGraphSnapshotCommand,
+  GetGraphSummaryCommand,
   GetImportTaskCommand,
   GetPrivateGraphEndpointCommand,
+  GetQueryCommand,
   ListGraphSnapshotsCommand,
   ListGraphsCommand,
   ListImportTasksCommand,
   ListPrivateGraphEndpointsCommand,
+  ListQueriesCommand,
   ListTagsForResourceCommand,
   ResetGraphCommand,
   RestoreGraphFromSnapshotCommand,
@@ -2780,19 +3353,29 @@ var import_util_endpoints = require("@aws-sdk/util-endpoints");
   waitUntilPrivateGraphEndpointAvailable,
   waitForPrivateGraphEndpointDeleted,
   waitUntilPrivateGraphEndpointDeleted,
-  ConflictExceptionReason,
-  ConflictException,
-  GraphStatus,
+  AccessDeniedException,
   InternalServerException,
-  ServiceQuotaExceededException,
+  ResourceNotFoundException,
   ThrottlingException,
   ValidationExceptionReason,
   ValidationException,
-  ResourceNotFoundException,
+  ConflictExceptionReason,
+  ConflictException,
+  ExplainMode,
+  QueryLanguage,
+  PlanCacheType,
+  UnprocessableExceptionReason,
+  UnprocessableException,
+  GraphSummaryMode,
+  QueryState,
+  GraphStatus,
+  ServiceQuotaExceededException,
+  QueryStateInput,
   PrivateGraphEndpointStatus,
   SnapshotStatus,
   Format,
   ImportTaskStatus,
-  ImportOptions
+  ImportOptions,
+  ExecuteQueryOutputFilterSensitiveLog
 });