@aws-sdk/client-neptune-graph 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,13 +1,2795 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NeptuneGraphServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./NeptuneGraphClient"), exports);
-tslib_1.__exportStar(require("./NeptuneGraph"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var NeptuneGraphServiceException_1 = require("./models/NeptuneGraphServiceException");
-Object.defineProperty(exports, "NeptuneGraphServiceException", { enumerable: true, get: function () { return NeptuneGraphServiceException_1.NeptuneGraphServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CancelImportTaskCommand: () => CancelImportTaskCommand,
+  ConflictException: () => ConflictException,
+  ConflictExceptionReason: () => ConflictExceptionReason,
+  CreateGraphCommand: () => CreateGraphCommand,
+  CreateGraphSnapshotCommand: () => CreateGraphSnapshotCommand,
+  CreateGraphUsingImportTaskCommand: () => CreateGraphUsingImportTaskCommand,
+  CreatePrivateGraphEndpointCommand: () => CreatePrivateGraphEndpointCommand,
+  DeleteGraphCommand: () => DeleteGraphCommand,
+  DeleteGraphSnapshotCommand: () => DeleteGraphSnapshotCommand,
+  DeletePrivateGraphEndpointCommand: () => DeletePrivateGraphEndpointCommand,
+  Format: () => Format,
+  GetGraphCommand: () => GetGraphCommand,
+  GetGraphSnapshotCommand: () => GetGraphSnapshotCommand,
+  GetImportTaskCommand: () => GetImportTaskCommand,
+  GetPrivateGraphEndpointCommand: () => GetPrivateGraphEndpointCommand,
+  GraphStatus: () => GraphStatus,
+  ImportOptions: () => ImportOptions,
+  ImportTaskStatus: () => ImportTaskStatus,
+  InternalServerException: () => InternalServerException,
+  ListGraphSnapshotsCommand: () => ListGraphSnapshotsCommand,
+  ListGraphsCommand: () => ListGraphsCommand,
+  ListImportTasksCommand: () => ListImportTasksCommand,
+  ListPrivateGraphEndpointsCommand: () => ListPrivateGraphEndpointsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  NeptuneGraph: () => NeptuneGraph,
+  NeptuneGraphClient: () => NeptuneGraphClient,
+  NeptuneGraphServiceException: () => NeptuneGraphServiceException,
+  PrivateGraphEndpointStatus: () => PrivateGraphEndpointStatus,
+  ResetGraphCommand: () => ResetGraphCommand,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  RestoreGraphFromSnapshotCommand: () => RestoreGraphFromSnapshotCommand,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  SnapshotStatus: () => SnapshotStatus,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottlingException: () => ThrottlingException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateGraphCommand: () => UpdateGraphCommand,
+  ValidationException: () => ValidationException,
+  ValidationExceptionReason: () => ValidationExceptionReason,
+  __Client: () => import_smithy_client.Client,
+  paginateListGraphSnapshots: () => paginateListGraphSnapshots,
+  paginateListGraphs: () => paginateListGraphs,
+  paginateListImportTasks: () => paginateListImportTasks,
+  paginateListPrivateGraphEndpoints: () => paginateListPrivateGraphEndpoints,
+  waitForGraphAvailable: () => waitForGraphAvailable,
+  waitForGraphDeleted: () => waitForGraphDeleted,
+  waitForGraphSnapshotAvailable: () => waitForGraphSnapshotAvailable,
+  waitForGraphSnapshotDeleted: () => waitForGraphSnapshotDeleted,
+  waitForImportTaskCancelled: () => waitForImportTaskCancelled,
+  waitForImportTaskSuccessful: () => waitForImportTaskSuccessful,
+  waitForPrivateGraphEndpointAvailable: () => waitForPrivateGraphEndpointAvailable,
+  waitForPrivateGraphEndpointDeleted: () => waitForPrivateGraphEndpointDeleted,
+  waitUntilGraphAvailable: () => waitUntilGraphAvailable,
+  waitUntilGraphDeleted: () => waitUntilGraphDeleted,
+  waitUntilGraphSnapshotAvailable: () => waitUntilGraphSnapshotAvailable,
+  waitUntilGraphSnapshotDeleted: () => waitUntilGraphSnapshotDeleted,
+  waitUntilImportTaskCancelled: () => waitUntilImportTaskCancelled,
+  waitUntilImportTaskSuccessful: () => waitUntilImportTaskSuccessful,
+  waitUntilPrivateGraphEndpointAvailable: () => waitUntilPrivateGraphEndpointAvailable,
+  waitUntilPrivateGraphEndpointDeleted: () => waitUntilPrivateGraphEndpointDeleted
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/NeptuneGraphClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    defaultSigningName: "neptune-graph"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/NeptuneGraphClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/NeptuneGraphClient.ts
+var _NeptuneGraphClient = class _NeptuneGraphClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_NeptuneGraphClient, "NeptuneGraphClient");
+var NeptuneGraphClient = _NeptuneGraphClient;
+
+// src/NeptuneGraph.ts
+
+
+// src/commands/CancelImportTaskCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+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 {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _NeptuneGraphServiceException.prototype);
+  }
+};
+__name(_NeptuneGraphServiceException, "NeptuneGraphServiceException");
+var NeptuneGraphServiceException = _NeptuneGraphServiceException;
+
+// src/models/models_0.ts
+var ConflictExceptionReason = {
+  CONCURRENT_MODIFICATION: "CONCURRENT_MODIFICATION"
+};
+var _ConflictException = class _ConflictException extends NeptuneGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.reason = opts.reason;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var GraphStatus = {
+  AVAILABLE: "AVAILABLE",
+  CREATING: "CREATING",
+  DELETING: "DELETING",
+  FAILED: "FAILED",
+  RESETTING: "RESETTING",
+  SNAPSHOTTING: "SNAPSHOTTING",
+  UPDATING: "UPDATING"
+};
+var _InternalServerException = class _InternalServerException extends NeptuneGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+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 _ThrottlingException = class _ThrottlingException extends NeptuneGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    this.$retryable = {
+      throttling: true
+    };
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var ValidationExceptionReason = {
+  BAD_REQUEST: "BAD_REQUEST",
+  CONSTRAINT_VIOLATION: "CONSTRAINT_VIOLATION",
+  ILLEGAL_ARGUMENT: "ILLEGAL_ARGUMENT",
+  MALFORMED_QUERY: "MALFORMED_QUERY",
+  QUERY_CANCELLED: "QUERY_CANCELLED",
+  QUERY_TOO_LARGE: "QUERY_TOO_LARGE",
+  UNSUPPORTED_OPERATION: "UNSUPPORTED_OPERATION"
+};
+var _ValidationException = class _ValidationException extends NeptuneGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.reason = opts.reason;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends NeptuneGraphServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var PrivateGraphEndpointStatus = {
+  AVAILABLE: "AVAILABLE",
+  CREATING: "CREATING",
+  DELETING: "DELETING",
+  FAILED: "FAILED"
+};
+var SnapshotStatus = {
+  AVAILABLE: "AVAILABLE",
+  CREATING: "CREATING",
+  DELETING: "DELETING",
+  FAILED: "FAILED"
+};
+var Format = {
+  CSV: "CSV",
+  OPEN_CYPHER: "OPEN_CYPHER"
+};
+var ImportTaskStatus = {
+  ANALYZING_DATA: "ANALYZING_DATA",
+  CANCELLED: "CANCELLED",
+  CANCELLING: "CANCELLING",
+  EXPORTING: "EXPORTING",
+  FAILED: "FAILED",
+  IMPORTING: "IMPORTING",
+  INITIALIZING: "INITIALIZING",
+  REPROVISIONING: "REPROVISIONING",
+  ROLLING_BACK: "ROLLING_BACK",
+  SUCCEEDED: "SUCCEEDED"
+};
+var ImportOptions;
+((ImportOptions3) => {
+  ImportOptions3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.neptune !== void 0)
+      return visitor.neptune(value.neptune);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ImportOptions || (ImportOptions = {}));
+
+// src/protocols/Aws_restJson1.ts
+var se_CancelImportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/importtasks/{taskIdentifier}");
+  b.p("taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_CancelImportTaskCommand");
+var se_CreateGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/graphs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      deletionProtection: [],
+      graphName: [],
+      kmsKeyIdentifier: [],
+      provisionedMemory: [],
+      publicConnectivity: [],
+      replicaCount: [],
+      tags: (_) => (0, import_smithy_client._json)(_),
+      vectorSearchConfiguration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateGraphCommand");
+var se_CreateGraphSnapshotCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/snapshots");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      graphIdentifier: [],
+      snapshotName: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateGraphSnapshotCommand");
+var se_CreateGraphUsingImportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/importtasks");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      deletionProtection: [],
+      failOnError: [],
+      format: [],
+      graphName: [],
+      importOptions: (_) => (0, import_smithy_client._json)(_),
+      kmsKeyIdentifier: [],
+      maxProvisionedMemory: [],
+      minProvisionedMemory: [],
+      publicConnectivity: [],
+      replicaCount: [],
+      roleArn: [],
+      source: [],
+      tags: (_) => (0, import_smithy_client._json)(_),
+      vectorSearchConfiguration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateGraphUsingImportTaskCommand");
+var se_CreatePrivateGraphEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/graphs/{graphIdentifier}/endpoints");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      subnetIds: (_) => (0, import_smithy_client._json)(_),
+      vpcId: [],
+      vpcSecurityGroupIds: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreatePrivateGraphEndpointCommand");
+var se_DeleteGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/graphs/{graphIdentifier}");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sS]: [(0, import_smithy_client.expectNonNull)(input.skipSnapshot, `skipSnapshot`) != null, () => input[_sS].toString()]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteGraphCommand");
+var se_DeleteGraphSnapshotCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/snapshots/{snapshotIdentifier}");
+  b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteGraphSnapshotCommand");
+var se_DeletePrivateGraphEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/graphs/{graphIdentifier}/endpoints/{vpcId}");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  b.p("vpcId", () => input.vpcId, "{vpcId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeletePrivateGraphEndpointCommand");
+var se_GetGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/graphs/{graphIdentifier}");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetGraphCommand");
+var se_GetGraphSnapshotCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/snapshots/{snapshotIdentifier}");
+  b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetGraphSnapshotCommand");
+var se_GetImportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/importtasks/{taskIdentifier}");
+  b.p("taskIdentifier", () => input.taskIdentifier, "{taskIdentifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetImportTaskCommand");
+var se_GetPrivateGraphEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/graphs/{graphIdentifier}/endpoints/{vpcId}");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  b.p("vpcId", () => input.vpcId, "{vpcId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetPrivateGraphEndpointCommand");
+var se_ListGraphsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/graphs");
+  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_ListGraphsCommand");
+var se_ListGraphSnapshotsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/snapshots");
+  const query = (0, import_smithy_client.map)({
+    [_gI]: [, input[_gI]],
+    [_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_ListGraphSnapshotsCommand");
+var se_ListImportTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/importtasks");
+  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_ListImportTasksCommand");
+var se_ListPrivateGraphEndpointsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/graphs/{graphIdentifier}/endpoints");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  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_ListPrivateGraphEndpointsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_ResetGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/graphs/{graphIdentifier}");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      skipSnapshot: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_ResetGraphCommand");
+var se_RestoreGraphFromSnapshotCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/snapshots/{snapshotIdentifier}/restore");
+  b.p("snapshotIdentifier", () => input.snapshotIdentifier, "{snapshotIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      deletionProtection: [],
+      graphName: [],
+      provisionedMemory: [],
+      publicConnectivity: [],
+      replicaCount: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_RestoreGraphFromSnapshotCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null,
+      () => (input[_tK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateGraphCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/graphs/{graphIdentifier}");
+  b.p("graphIdentifier", () => input.graphIdentifier, "{graphIdentifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      deletionProtection: [],
+      provisionedMemory: [],
+      publicConnectivity: []
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_UpdateGraphCommand");
+var de_CancelImportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CancelImportTaskCommandError(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, {
+    format: import_smithy_client.expectString,
+    graphId: import_smithy_client.expectString,
+    roleArn: import_smithy_client.expectString,
+    source: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    taskId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CancelImportTaskCommand");
+var de_CancelImportTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "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_CancelImportTaskCommandError");
+var de_CreateGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateGraphCommandError(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, {
+    arn: import_smithy_client.expectString,
+    buildNumber: import_smithy_client.expectString,
+    createTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deletionProtection: import_smithy_client.expectBoolean,
+    endpoint: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    provisionedMemory: import_smithy_client.expectInt32,
+    publicConnectivity: import_smithy_client.expectBoolean,
+    replicaCount: import_smithy_client.expectInt32,
+    sourceSnapshotId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    vectorSearchConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateGraphCommand");
+var de_CreateGraphCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "ServiceQuotaExceededException":
+    case "com.amazonaws.neptunegraph#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(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_CreateGraphCommandError");
+var de_CreateGraphSnapshotCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateGraphSnapshotCommandError(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, {
+    arn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    snapshotCreateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    sourceGraphId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateGraphSnapshotCommand");
+var de_CreateGraphSnapshotCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "ResourceNotFoundException":
+    case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.neptunegraph#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(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_CreateGraphSnapshotCommandError");
+var de_CreateGraphUsingImportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateGraphUsingImportTaskCommandError(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, {
+    format: import_smithy_client.expectString,
+    graphId: import_smithy_client.expectString,
+    importOptions: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    roleArn: import_smithy_client.expectString,
+    source: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    taskId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateGraphUsingImportTaskCommand");
+var de_CreateGraphUsingImportTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "ServiceQuotaExceededException":
+    case "com.amazonaws.neptunegraph#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(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_CreateGraphUsingImportTaskCommandError");
+var de_CreatePrivateGraphEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreatePrivateGraphEndpointCommandError(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, {
+    status: import_smithy_client.expectString,
+    subnetIds: import_smithy_client._json,
+    vpcEndpointId: import_smithy_client.expectString,
+    vpcId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreatePrivateGraphEndpointCommand");
+var de_CreatePrivateGraphEndpointCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "ResourceNotFoundException":
+    case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.neptunegraph#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(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_CreatePrivateGraphEndpointCommandError");
+var de_DeleteGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteGraphCommandError(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, {
+    arn: import_smithy_client.expectString,
+    buildNumber: import_smithy_client.expectString,
+    createTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deletionProtection: import_smithy_client.expectBoolean,
+    endpoint: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    provisionedMemory: import_smithy_client.expectInt32,
+    publicConnectivity: import_smithy_client.expectBoolean,
+    replicaCount: import_smithy_client.expectInt32,
+    sourceSnapshotId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    vectorSearchConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteGraphCommand");
+var de_DeleteGraphCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "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_DeleteGraphCommandError");
+var de_DeleteGraphSnapshotCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteGraphSnapshotCommandError(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, {
+    arn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    snapshotCreateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    sourceGraphId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteGraphSnapshotCommand");
+var de_DeleteGraphSnapshotCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "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_DeleteGraphSnapshotCommandError");
+var de_DeletePrivateGraphEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeletePrivateGraphEndpointCommandError(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, {
+    status: import_smithy_client.expectString,
+    subnetIds: import_smithy_client._json,
+    vpcEndpointId: import_smithy_client.expectString,
+    vpcId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeletePrivateGraphEndpointCommand");
+var de_DeletePrivateGraphEndpointCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "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_DeletePrivateGraphEndpointCommandError");
+var de_GetGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGraphCommandError(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, {
+    arn: import_smithy_client.expectString,
+    buildNumber: import_smithy_client.expectString,
+    createTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deletionProtection: import_smithy_client.expectBoolean,
+    endpoint: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    provisionedMemory: import_smithy_client.expectInt32,
+    publicConnectivity: import_smithy_client.expectBoolean,
+    replicaCount: import_smithy_client.expectInt32,
+    sourceSnapshotId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    vectorSearchConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGraphCommand");
+var de_GetGraphCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_GetGraphCommandError");
+var de_GetGraphSnapshotCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetGraphSnapshotCommandError(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, {
+    arn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    snapshotCreateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    sourceGraphId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetGraphSnapshotCommand");
+var de_GetGraphSnapshotCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_GetGraphSnapshotCommandError");
+var de_GetImportTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetImportTaskCommandError(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, {
+    attemptNumber: import_smithy_client.expectInt32,
+    format: import_smithy_client.expectString,
+    graphId: import_smithy_client.expectString,
+    importOptions: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    importTaskDetails: (_) => de_ImportTaskDetails(_, context),
+    roleArn: import_smithy_client.expectString,
+    source: 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_GetImportTaskCommand");
+var de_GetImportTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_GetImportTaskCommandError");
+var de_GetPrivateGraphEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetPrivateGraphEndpointCommandError(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, {
+    status: import_smithy_client.expectString,
+    subnetIds: import_smithy_client._json,
+    vpcEndpointId: import_smithy_client.expectString,
+    vpcId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetPrivateGraphEndpointCommand");
+var de_GetPrivateGraphEndpointCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_GetPrivateGraphEndpointCommandError");
+var de_ListGraphsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListGraphsCommandError(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, {
+    graphs: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListGraphsCommand");
+var de_ListGraphsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListGraphsCommandError");
+var de_ListGraphSnapshotsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListGraphSnapshotsCommandError(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, {
+    graphSnapshots: (_) => de_GraphSnapshotSummaryList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListGraphSnapshotsCommand");
+var de_ListGraphSnapshotsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_ListGraphSnapshotsCommandError");
+var de_ListImportTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListImportTasksCommandError(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, {
+    nextToken: import_smithy_client.expectString,
+    tasks: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListImportTasksCommand");
+var de_ListImportTasksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_ListImportTasksCommandError");
+var de_ListPrivateGraphEndpointsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListPrivateGraphEndpointsCommandError(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, {
+    nextToken: import_smithy_client.expectString,
+    privateGraphEndpoints: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListPrivateGraphEndpointsCommand");
+var de_ListPrivateGraphEndpointsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_ListPrivateGraphEndpointsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(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, {
+    tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_ListTagsForResourceCommandError");
+var de_ResetGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ResetGraphCommandError(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, {
+    arn: import_smithy_client.expectString,
+    buildNumber: import_smithy_client.expectString,
+    createTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deletionProtection: import_smithy_client.expectBoolean,
+    endpoint: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    provisionedMemory: import_smithy_client.expectInt32,
+    publicConnectivity: import_smithy_client.expectBoolean,
+    replicaCount: import_smithy_client.expectInt32,
+    sourceSnapshotId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    vectorSearchConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ResetGraphCommand");
+var de_ResetGraphCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "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_ResetGraphCommandError");
+var de_RestoreGraphFromSnapshotCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_RestoreGraphFromSnapshotCommandError(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, {
+    arn: import_smithy_client.expectString,
+    buildNumber: import_smithy_client.expectString,
+    createTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deletionProtection: import_smithy_client.expectBoolean,
+    endpoint: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    provisionedMemory: import_smithy_client.expectInt32,
+    publicConnectivity: import_smithy_client.expectBoolean,
+    replicaCount: import_smithy_client.expectInt32,
+    sourceSnapshotId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    vectorSearchConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_RestoreGraphFromSnapshotCommand");
+var de_RestoreGraphFromSnapshotCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "ResourceNotFoundException":
+    case "com.amazonaws.neptunegraph#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.neptunegraph#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(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_RestoreGraphFromSnapshotCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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_UntagResourceCommandError");
+var de_UpdateGraphCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateGraphCommandError(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, {
+    arn: import_smithy_client.expectString,
+    buildNumber: import_smithy_client.expectString,
+    createTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deletionProtection: import_smithy_client.expectBoolean,
+    endpoint: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    provisionedMemory: import_smithy_client.expectInt32,
+    publicConnectivity: import_smithy_client.expectBoolean,
+    replicaCount: import_smithy_client.expectInt32,
+    sourceSnapshotId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusReason: import_smithy_client.expectString,
+    vectorSearchConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateGraphCommand");
+var de_UpdateGraphCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    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 "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_UpdateGraphCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(NeptuneGraphServiceException);
+var de_ConflictExceptionRes = /* @__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 ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__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 InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__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 ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__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,
+    quotaCode: import_smithy_client.expectString,
+    resourceId: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    serviceCode: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ThrottlingExceptionRes = /* @__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 ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__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 ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var de_GraphSnapshotSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    kmsKeyIdentifier: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    snapshotCreateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    sourceGraphId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString
+  });
+}, "de_GraphSnapshotSummary");
+var de_GraphSnapshotSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_GraphSnapshotSummary(entry, context);
+  });
+  return retVal;
+}, "de_GraphSnapshotSummaryList");
+var de_ImportTaskDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    dictionaryEntryCount: import_smithy_client.expectLong,
+    errorCount: import_smithy_client.expectInt32,
+    errorDetails: import_smithy_client.expectString,
+    progressPercentage: import_smithy_client.expectInt32,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    statementCount: import_smithy_client.expectLong,
+    status: import_smithy_client.expectString,
+    timeElapsedSeconds: import_smithy_client.expectLong
+  });
+}, "de_ImportTaskDetails");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  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 _gI = "graphIdentifier";
+var _mR = "maxResults";
+var _nT = "nextToken";
+var _sS = "skipSnapshot";
+var _tK = "tagKeys";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CancelImportTaskCommand.ts
+var _CancelImportTaskCommand = class _CancelImportTaskCommand 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", "CancelImportTask", {}).n("NeptuneGraphClient", "CancelImportTaskCommand").f(void 0, void 0).ser(se_CancelImportTaskCommand).de(de_CancelImportTaskCommand).build() {
+};
+__name(_CancelImportTaskCommand, "CancelImportTaskCommand");
+var CancelImportTaskCommand = _CancelImportTaskCommand;
+
+// src/commands/CreateGraphCommand.ts
+
+
+
+
+var _CreateGraphCommand = class _CreateGraphCommand 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", "CreateGraph", {}).n("NeptuneGraphClient", "CreateGraphCommand").f(void 0, void 0).ser(se_CreateGraphCommand).de(de_CreateGraphCommand).build() {
+};
+__name(_CreateGraphCommand, "CreateGraphCommand");
+var CreateGraphCommand = _CreateGraphCommand;
+
+// src/commands/CreateGraphSnapshotCommand.ts
+
+
+
+
+var _CreateGraphSnapshotCommand = class _CreateGraphSnapshotCommand 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", "CreateGraphSnapshot", {}).n("NeptuneGraphClient", "CreateGraphSnapshotCommand").f(void 0, void 0).ser(se_CreateGraphSnapshotCommand).de(de_CreateGraphSnapshotCommand).build() {
+};
+__name(_CreateGraphSnapshotCommand, "CreateGraphSnapshotCommand");
+var CreateGraphSnapshotCommand = _CreateGraphSnapshotCommand;
+
+// src/commands/CreateGraphUsingImportTaskCommand.ts
+
+
+
+
+var _CreateGraphUsingImportTaskCommand = class _CreateGraphUsingImportTaskCommand 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", "CreateGraphUsingImportTask", {}).n("NeptuneGraphClient", "CreateGraphUsingImportTaskCommand").f(void 0, void 0).ser(se_CreateGraphUsingImportTaskCommand).de(de_CreateGraphUsingImportTaskCommand).build() {
+};
+__name(_CreateGraphUsingImportTaskCommand, "CreateGraphUsingImportTaskCommand");
+var CreateGraphUsingImportTaskCommand = _CreateGraphUsingImportTaskCommand;
+
+// src/commands/CreatePrivateGraphEndpointCommand.ts
+
+
+
+
+var _CreatePrivateGraphEndpointCommand = class _CreatePrivateGraphEndpointCommand 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", "CreatePrivateGraphEndpoint", {}).n("NeptuneGraphClient", "CreatePrivateGraphEndpointCommand").f(void 0, void 0).ser(se_CreatePrivateGraphEndpointCommand).de(de_CreatePrivateGraphEndpointCommand).build() {
+};
+__name(_CreatePrivateGraphEndpointCommand, "CreatePrivateGraphEndpointCommand");
+var CreatePrivateGraphEndpointCommand = _CreatePrivateGraphEndpointCommand;
+
+// src/commands/DeleteGraphCommand.ts
+
+
+
+
+var _DeleteGraphCommand = class _DeleteGraphCommand 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", "DeleteGraph", {}).n("NeptuneGraphClient", "DeleteGraphCommand").f(void 0, void 0).ser(se_DeleteGraphCommand).de(de_DeleteGraphCommand).build() {
+};
+__name(_DeleteGraphCommand, "DeleteGraphCommand");
+var DeleteGraphCommand = _DeleteGraphCommand;
+
+// src/commands/DeleteGraphSnapshotCommand.ts
+
+
+
+
+var _DeleteGraphSnapshotCommand = class _DeleteGraphSnapshotCommand 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", "DeleteGraphSnapshot", {}).n("NeptuneGraphClient", "DeleteGraphSnapshotCommand").f(void 0, void 0).ser(se_DeleteGraphSnapshotCommand).de(de_DeleteGraphSnapshotCommand).build() {
+};
+__name(_DeleteGraphSnapshotCommand, "DeleteGraphSnapshotCommand");
+var DeleteGraphSnapshotCommand = _DeleteGraphSnapshotCommand;
+
+// src/commands/DeletePrivateGraphEndpointCommand.ts
+
+
+
+
+var _DeletePrivateGraphEndpointCommand = class _DeletePrivateGraphEndpointCommand 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", "DeletePrivateGraphEndpoint", {}).n("NeptuneGraphClient", "DeletePrivateGraphEndpointCommand").f(void 0, void 0).ser(se_DeletePrivateGraphEndpointCommand).de(de_DeletePrivateGraphEndpointCommand).build() {
+};
+__name(_DeletePrivateGraphEndpointCommand, "DeletePrivateGraphEndpointCommand");
+var DeletePrivateGraphEndpointCommand = _DeletePrivateGraphEndpointCommand;
+
+// src/commands/GetGraphCommand.ts
+
+
+
+
+var _GetGraphCommand = class _GetGraphCommand 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", "GetGraph", {}).n("NeptuneGraphClient", "GetGraphCommand").f(void 0, void 0).ser(se_GetGraphCommand).de(de_GetGraphCommand).build() {
+};
+__name(_GetGraphCommand, "GetGraphCommand");
+var GetGraphCommand = _GetGraphCommand;
+
+// src/commands/GetGraphSnapshotCommand.ts
+
+
+
+
+var _GetGraphSnapshotCommand = class _GetGraphSnapshotCommand 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", "GetGraphSnapshot", {}).n("NeptuneGraphClient", "GetGraphSnapshotCommand").f(void 0, void 0).ser(se_GetGraphSnapshotCommand).de(de_GetGraphSnapshotCommand).build() {
+};
+__name(_GetGraphSnapshotCommand, "GetGraphSnapshotCommand");
+var GetGraphSnapshotCommand = _GetGraphSnapshotCommand;
+
+// src/commands/GetImportTaskCommand.ts
+
+
+
+
+var _GetImportTaskCommand = class _GetImportTaskCommand 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", "GetImportTask", {}).n("NeptuneGraphClient", "GetImportTaskCommand").f(void 0, void 0).ser(se_GetImportTaskCommand).de(de_GetImportTaskCommand).build() {
+};
+__name(_GetImportTaskCommand, "GetImportTaskCommand");
+var GetImportTaskCommand = _GetImportTaskCommand;
+
+// src/commands/GetPrivateGraphEndpointCommand.ts
+
+
+
+
+var _GetPrivateGraphEndpointCommand = class _GetPrivateGraphEndpointCommand 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", "GetPrivateGraphEndpoint", {}).n("NeptuneGraphClient", "GetPrivateGraphEndpointCommand").f(void 0, void 0).ser(se_GetPrivateGraphEndpointCommand).de(de_GetPrivateGraphEndpointCommand).build() {
+};
+__name(_GetPrivateGraphEndpointCommand, "GetPrivateGraphEndpointCommand");
+var GetPrivateGraphEndpointCommand = _GetPrivateGraphEndpointCommand;
+
+// src/commands/ListGraphsCommand.ts
+
+
+
+
+var _ListGraphsCommand = class _ListGraphsCommand 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", "ListGraphs", {}).n("NeptuneGraphClient", "ListGraphsCommand").f(void 0, void 0).ser(se_ListGraphsCommand).de(de_ListGraphsCommand).build() {
+};
+__name(_ListGraphsCommand, "ListGraphsCommand");
+var ListGraphsCommand = _ListGraphsCommand;
+
+// src/commands/ListGraphSnapshotsCommand.ts
+
+
+
+
+var _ListGraphSnapshotsCommand = class _ListGraphSnapshotsCommand 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", "ListGraphSnapshots", {}).n("NeptuneGraphClient", "ListGraphSnapshotsCommand").f(void 0, void 0).ser(se_ListGraphSnapshotsCommand).de(de_ListGraphSnapshotsCommand).build() {
+};
+__name(_ListGraphSnapshotsCommand, "ListGraphSnapshotsCommand");
+var ListGraphSnapshotsCommand = _ListGraphSnapshotsCommand;
+
+// src/commands/ListImportTasksCommand.ts
+
+
+
+
+var _ListImportTasksCommand = class _ListImportTasksCommand 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", "ListImportTasks", {}).n("NeptuneGraphClient", "ListImportTasksCommand").f(void 0, void 0).ser(se_ListImportTasksCommand).de(de_ListImportTasksCommand).build() {
+};
+__name(_ListImportTasksCommand, "ListImportTasksCommand");
+var ListImportTasksCommand = _ListImportTasksCommand;
+
+// src/commands/ListPrivateGraphEndpointsCommand.ts
+
+
+
+
+var _ListPrivateGraphEndpointsCommand = class _ListPrivateGraphEndpointsCommand 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", "ListPrivateGraphEndpoints", {}).n("NeptuneGraphClient", "ListPrivateGraphEndpointsCommand").f(void 0, void 0).ser(se_ListPrivateGraphEndpointsCommand).de(de_ListPrivateGraphEndpointsCommand).build() {
+};
+__name(_ListPrivateGraphEndpointsCommand, "ListPrivateGraphEndpointsCommand");
+var ListPrivateGraphEndpointsCommand = _ListPrivateGraphEndpointsCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand 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", "ListTagsForResource", {}).n("NeptuneGraphClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ResetGraphCommand.ts
+
+
+
+
+var _ResetGraphCommand = class _ResetGraphCommand 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", "ResetGraph", {}).n("NeptuneGraphClient", "ResetGraphCommand").f(void 0, void 0).ser(se_ResetGraphCommand).de(de_ResetGraphCommand).build() {
+};
+__name(_ResetGraphCommand, "ResetGraphCommand");
+var ResetGraphCommand = _ResetGraphCommand;
+
+// src/commands/RestoreGraphFromSnapshotCommand.ts
+
+
+
+
+var _RestoreGraphFromSnapshotCommand = class _RestoreGraphFromSnapshotCommand 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", "RestoreGraphFromSnapshot", {}).n("NeptuneGraphClient", "RestoreGraphFromSnapshotCommand").f(void 0, void 0).ser(se_RestoreGraphFromSnapshotCommand).de(de_RestoreGraphFromSnapshotCommand).build() {
+};
+__name(_RestoreGraphFromSnapshotCommand, "RestoreGraphFromSnapshotCommand");
+var RestoreGraphFromSnapshotCommand = _RestoreGraphFromSnapshotCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand 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", "TagResource", {}).n("NeptuneGraphClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand 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", "UntagResource", {}).n("NeptuneGraphClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateGraphCommand.ts
+
+
+
+
+var _UpdateGraphCommand = class _UpdateGraphCommand 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", "UpdateGraph", {}).n("NeptuneGraphClient", "UpdateGraphCommand").f(void 0, void 0).ser(se_UpdateGraphCommand).de(de_UpdateGraphCommand).build() {
+};
+__name(_UpdateGraphCommand, "UpdateGraphCommand");
+var UpdateGraphCommand = _UpdateGraphCommand;
+
+// src/NeptuneGraph.ts
+var commands = {
+  CancelImportTaskCommand,
+  CreateGraphCommand,
+  CreateGraphSnapshotCommand,
+  CreateGraphUsingImportTaskCommand,
+  CreatePrivateGraphEndpointCommand,
+  DeleteGraphCommand,
+  DeleteGraphSnapshotCommand,
+  DeletePrivateGraphEndpointCommand,
+  GetGraphCommand,
+  GetGraphSnapshotCommand,
+  GetImportTaskCommand,
+  GetPrivateGraphEndpointCommand,
+  ListGraphsCommand,
+  ListGraphSnapshotsCommand,
+  ListImportTasksCommand,
+  ListPrivateGraphEndpointsCommand,
+  ListTagsForResourceCommand,
+  ResetGraphCommand,
+  RestoreGraphFromSnapshotCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateGraphCommand
+};
+var _NeptuneGraph = class _NeptuneGraph extends NeptuneGraphClient {
+};
+__name(_NeptuneGraph, "NeptuneGraph");
+var NeptuneGraph = _NeptuneGraph;
+(0, import_smithy_client.createAggregatedClient)(commands, NeptuneGraph);
+
+// src/pagination/ListGraphSnapshotsPaginator.ts
+var import_core3 = require("@smithy/core");
+var paginateListGraphSnapshots = (0, import_core3.createPaginator)(NeptuneGraphClient, ListGraphSnapshotsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListGraphsPaginator.ts
+var import_core4 = require("@smithy/core");
+var paginateListGraphs = (0, import_core4.createPaginator)(NeptuneGraphClient, ListGraphsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListImportTasksPaginator.ts
+var import_core5 = require("@smithy/core");
+var paginateListImportTasks = (0, import_core5.createPaginator)(NeptuneGraphClient, ListImportTasksCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListPrivateGraphEndpointsPaginator.ts
+var import_core6 = require("@smithy/core");
+var paginateListPrivateGraphEndpoints = (0, import_core6.createPaginator)(NeptuneGraphClient, ListPrivateGraphEndpointsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/waiters/waitForGraphAvailable.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 GetGraphCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETING") {
+        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() === "AVAILABLE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForGraphAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "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);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilGraphAvailable");
+
+// src/waiters/waitForGraphDeleted.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetGraphCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status != "DELETING";
+      }, "returnComparator");
+      if (returnComparator() == true) {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForGraphDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "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);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilGraphDeleted");
+
+// src/waiters/waitForGraphSnapshotAvailable.ts
+
+var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetGraphSnapshotCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETING") {
+        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() === "AVAILABLE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForGraphSnapshotAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 7200 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+}, "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);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilGraphSnapshotAvailable");
+
+// src/waiters/waitForGraphSnapshotDeleted.ts
+
+var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetGraphSnapshotCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status != "DELETING";
+      }, "returnComparator");
+      if (returnComparator() == true) {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForGraphSnapshotDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+}, "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);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilGraphSnapshotDeleted");
+
+// src/waiters/waitForImportTaskCancelled.ts
+
+var checkState5 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetImportTaskCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status != "CANCELLING";
+      }, "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 waitForImportTaskCancelled = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 3600 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState5);
+}, "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);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilImportTaskCancelled");
+
+// src/waiters/waitForImportTaskSuccessful.ts
+
+var checkState6 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetImportTaskCommand(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() === "ROLLING_BACK") {
+        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 waitForImportTaskSuccessful = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 60, maxDelay: 28800 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState6);
+}, "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);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilImportTaskSuccessful");
+
+// src/waiters/waitForPrivateGraphEndpointAvailable.ts
+
+var checkState7 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetPrivateGraphEndpointCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETING") {
+        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() === "AVAILABLE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForPrivateGraphEndpointAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState7);
+}, "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);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilPrivateGraphEndpointAvailable");
+
+// src/waiters/waitForPrivateGraphEndpointDeleted.ts
+
+var checkState8 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetPrivateGraphEndpointCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.status != "DELETING";
+      }, "returnComparator");
+      if (returnComparator() == true) {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForPrivateGraphEndpointDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 10, maxDelay: 1800 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState8);
+}, "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);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilPrivateGraphEndpointDeleted");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CancelImportTaskCommand,
+  ConflictException,
+  ConflictExceptionReason,
+  CreateGraphCommand,
+  CreateGraphSnapshotCommand,
+  CreateGraphUsingImportTaskCommand,
+  CreatePrivateGraphEndpointCommand,
+  DeleteGraphCommand,
+  DeleteGraphSnapshotCommand,
+  DeletePrivateGraphEndpointCommand,
+  Format,
+  GetGraphCommand,
+  GetGraphSnapshotCommand,
+  GetImportTaskCommand,
+  GetPrivateGraphEndpointCommand,
+  GraphStatus,
+  ImportOptions,
+  ImportTaskStatus,
+  InternalServerException,
+  ListGraphSnapshotsCommand,
+  ListGraphsCommand,
+  ListImportTasksCommand,
+  ListPrivateGraphEndpointsCommand,
+  ListTagsForResourceCommand,
+  NeptuneGraph,
+  NeptuneGraphClient,
+  NeptuneGraphServiceException,
+  PrivateGraphEndpointStatus,
+  ResetGraphCommand,
+  ResourceNotFoundException,
+  RestoreGraphFromSnapshotCommand,
+  ServiceQuotaExceededException,
+  SnapshotStatus,
+  TagResourceCommand,
+  ThrottlingException,
+  UntagResourceCommand,
+  UpdateGraphCommand,
+  ValidationException,
+  ValidationExceptionReason,
+  __Client,
+  paginateListGraphSnapshots,
+  paginateListGraphs,
+  paginateListImportTasks,
+  paginateListPrivateGraphEndpoints,
+  waitForGraphAvailable,
+  waitForGraphDeleted,
+  waitForGraphSnapshotAvailable,
+  waitForGraphSnapshotDeleted,
+  waitForImportTaskCancelled,
+  waitForImportTaskSuccessful,
+  waitForPrivateGraphEndpointAvailable,
+  waitForPrivateGraphEndpointDeleted,
+  waitUntilGraphAvailable,
+  waitUntilGraphDeleted,
+  waitUntilGraphSnapshotAvailable,
+  waitUntilGraphSnapshotDeleted,
+  waitUntilImportTaskCancelled,
+  waitUntilImportTaskSuccessful,
+  waitUntilPrivateGraphEndpointAvailable,
+  waitUntilPrivateGraphEndpointDeleted
+});