File Explorer

1"use strict";2var __defProp = Object.defineProperty;3var __getOwnPropDesc = Object.getOwnPropertyDescriptor;4var __getOwnPropNames = Object.getOwnPropertyNames;5var __hasOwnProp = Object.prototype.hasOwnProperty;6var __name = (target, value) => __defProp(target, "name", { value, configurable: true });7var __export = (target, all) => {8  for (var name in all)9    __defProp(target, name, { get: all[name], enumerable: true });10};11var __copyProps = (to, from, except, desc) => {12  if (from && typeof from === "object" || typeof from === "function") {13    for (let key of __getOwnPropNames(from))14      if (!__hasOwnProp.call(to, key) && key !== except)15        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });16  }17  return to;18};19var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);20 21// src/index.ts22var index_exports = {};23__export(index_exports, {24  AccessDeniedException: () => AccessDeniedException,25  Action: () => Action,26  BadRequestException: () => BadRequestException,27  BulkLoadIdNotFoundException: () => BulkLoadIdNotFoundException,28  CancelGremlinQueryCommand: () => CancelGremlinQueryCommand,29  CancelLoaderJobCommand: () => CancelLoaderJobCommand,30  CancelMLDataProcessingJobCommand: () => CancelMLDataProcessingJobCommand,31  CancelMLModelTrainingJobCommand: () => CancelMLModelTrainingJobCommand,32  CancelMLModelTransformJobCommand: () => CancelMLModelTransformJobCommand,33  CancelOpenCypherQueryCommand: () => CancelOpenCypherQueryCommand,34  CancelledByUserException: () => CancelledByUserException,35  ClientTimeoutException: () => ClientTimeoutException,36  ConcurrentModificationException: () => ConcurrentModificationException,37  ConstraintViolationException: () => ConstraintViolationException,38  CreateMLEndpointCommand: () => CreateMLEndpointCommand,39  DeleteMLEndpointCommand: () => DeleteMLEndpointCommand,40  DeletePropertygraphStatisticsCommand: () => DeletePropertygraphStatisticsCommand,41  DeleteSparqlStatisticsCommand: () => DeleteSparqlStatisticsCommand,42  Encoding: () => Encoding,43  ExecuteFastResetCommand: () => ExecuteFastResetCommand,44  ExecuteGremlinExplainQueryCommand: () => ExecuteGremlinExplainQueryCommand,45  ExecuteGremlinProfileQueryCommand: () => ExecuteGremlinProfileQueryCommand,46  ExecuteGremlinQueryCommand: () => ExecuteGremlinQueryCommand,47  ExecuteOpenCypherExplainQueryCommand: () => ExecuteOpenCypherExplainQueryCommand,48  ExecuteOpenCypherQueryCommand: () => ExecuteOpenCypherQueryCommand,49  ExpiredStreamException: () => ExpiredStreamException,50  FailureByQueryException: () => FailureByQueryException,51  Format: () => Format,52  GetEngineStatusCommand: () => GetEngineStatusCommand,53  GetGremlinQueryStatusCommand: () => GetGremlinQueryStatusCommand,54  GetLoaderJobStatusCommand: () => GetLoaderJobStatusCommand,55  GetMLDataProcessingJobCommand: () => GetMLDataProcessingJobCommand,56  GetMLEndpointCommand: () => GetMLEndpointCommand,57  GetMLModelTrainingJobCommand: () => GetMLModelTrainingJobCommand,58  GetMLModelTransformJobCommand: () => GetMLModelTransformJobCommand,59  GetOpenCypherQueryStatusCommand: () => GetOpenCypherQueryStatusCommand,60  GetPropertygraphStatisticsCommand: () => GetPropertygraphStatisticsCommand,61  GetPropertygraphStreamCommand: () => GetPropertygraphStreamCommand,62  GetPropertygraphSummaryCommand: () => GetPropertygraphSummaryCommand,63  GetRDFGraphSummaryCommand: () => GetRDFGraphSummaryCommand,64  GetSparqlStatisticsCommand: () => GetSparqlStatisticsCommand,65  GetSparqlStreamCommand: () => GetSparqlStreamCommand,66  GraphSummaryType: () => GraphSummaryType,67  IllegalArgumentException: () => IllegalArgumentException,68  InternalFailureException: () => InternalFailureException,69  InvalidArgumentException: () => InvalidArgumentException,70  InvalidNumericDataException: () => InvalidNumericDataException,71  InvalidParameterException: () => InvalidParameterException,72  IteratorType: () => IteratorType,73  ListGremlinQueriesCommand: () => ListGremlinQueriesCommand,74  ListLoaderJobsCommand: () => ListLoaderJobsCommand,75  ListMLDataProcessingJobsCommand: () => ListMLDataProcessingJobsCommand,76  ListMLEndpointsCommand: () => ListMLEndpointsCommand,77  ListMLModelTrainingJobsCommand: () => ListMLModelTrainingJobsCommand,78  ListMLModelTransformJobsCommand: () => ListMLModelTransformJobsCommand,79  ListOpenCypherQueriesCommand: () => ListOpenCypherQueriesCommand,80  LoadUrlAccessDeniedException: () => LoadUrlAccessDeniedException,81  MLResourceNotFoundException: () => MLResourceNotFoundException,82  MalformedQueryException: () => MalformedQueryException,83  ManagePropertygraphStatisticsCommand: () => ManagePropertygraphStatisticsCommand,84  ManageSparqlStatisticsCommand: () => ManageSparqlStatisticsCommand,85  MemoryLimitExceededException: () => MemoryLimitExceededException,86  MethodNotAllowedException: () => MethodNotAllowedException,87  MissingParameterException: () => MissingParameterException,88  Mode: () => Mode,89  Neptunedata: () => Neptunedata,90  NeptunedataClient: () => NeptunedataClient,91  NeptunedataServiceException: () => NeptunedataServiceException,92  OpenCypherExplainMode: () => OpenCypherExplainMode,93  Parallelism: () => Parallelism,94  ParsingException: () => ParsingException,95  PreconditionsFailedException: () => PreconditionsFailedException,96  QueryLimitExceededException: () => QueryLimitExceededException,97  QueryLimitException: () => QueryLimitException,98  QueryTooLargeException: () => QueryTooLargeException,99  ReadOnlyViolationException: () => ReadOnlyViolationException,100  S3BucketRegion: () => S3BucketRegion,101  S3Exception: () => S3Exception,102  ServerShutdownException: () => ServerShutdownException,103  StartLoaderJobCommand: () => StartLoaderJobCommand,104  StartMLDataProcessingJobCommand: () => StartMLDataProcessingJobCommand,105  StartMLModelTrainingJobCommand: () => StartMLModelTrainingJobCommand,106  StartMLModelTransformJobCommand: () => StartMLModelTransformJobCommand,107  StatisticsAutoGenerationMode: () => StatisticsAutoGenerationMode,108  StatisticsNotAvailableException: () => StatisticsNotAvailableException,109  StreamRecordsNotFoundException: () => StreamRecordsNotFoundException,110  ThrottlingException: () => ThrottlingException,111  TimeLimitExceededException: () => TimeLimitExceededException,112  TooManyRequestsException: () => TooManyRequestsException,113  UnsupportedOperationException: () => UnsupportedOperationException,114  __Client: () => import_smithy_client.Client115});116module.exports = __toCommonJS(index_exports);117 118// src/NeptunedataClient.ts119var import_middleware_host_header = require("@aws-sdk/middleware-host-header");120var import_middleware_logger = require("@aws-sdk/middleware-logger");121var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");122var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");123var import_config_resolver = require("@smithy/config-resolver");124var import_core = require("@smithy/core");125var import_middleware_content_length = require("@smithy/middleware-content-length");126var import_middleware_endpoint = require("@smithy/middleware-endpoint");127var import_middleware_retry = require("@smithy/middleware-retry");128 129var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");130 131// src/endpoint/EndpointParameters.ts132var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {133  return Object.assign(options, {134    useDualstackEndpoint: options.useDualstackEndpoint ?? false,135    useFipsEndpoint: options.useFipsEndpoint ?? false,136    defaultSigningName: "neptune-db"137  });138}, "resolveClientEndpointParameters");139var commonParams = {140  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },141  Endpoint: { type: "builtInParams", name: "endpoint" },142  Region: { type: "builtInParams", name: "region" },143  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }144};145 146// src/NeptunedataClient.ts147var import_runtimeConfig = require("././runtimeConfig");148 149// src/runtimeExtensions.ts150var import_region_config_resolver = require("@aws-sdk/region-config-resolver");151var import_protocol_http = require("@smithy/protocol-http");152var import_smithy_client = require("@smithy/smithy-client");153 154// src/auth/httpAuthExtensionConfiguration.ts155var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {156  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;157  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;158  let _credentials = runtimeConfig.credentials;159  return {160    setHttpAuthScheme(httpAuthScheme) {161      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);162      if (index === -1) {163        _httpAuthSchemes.push(httpAuthScheme);164      } else {165        _httpAuthSchemes.splice(index, 1, httpAuthScheme);166      }167    },168    httpAuthSchemes() {169      return _httpAuthSchemes;170    },171    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {172      _httpAuthSchemeProvider = httpAuthSchemeProvider;173    },174    httpAuthSchemeProvider() {175      return _httpAuthSchemeProvider;176    },177    setCredentials(credentials) {178      _credentials = credentials;179    },180    credentials() {181      return _credentials;182    }183  };184}, "getHttpAuthExtensionConfiguration");185var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {186  return {187    httpAuthSchemes: config.httpAuthSchemes(),188    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),189    credentials: config.credentials()190  };191}, "resolveHttpAuthRuntimeConfig");192 193// src/runtimeExtensions.ts194var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {195  const extensionConfiguration = Object.assign(196    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),197    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),198    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),199    getHttpAuthExtensionConfiguration(runtimeConfig)200  );201  extensions.forEach((extension) => extension.configure(extensionConfiguration));202  return Object.assign(203    runtimeConfig,204    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),205    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),206    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),207    resolveHttpAuthRuntimeConfig(extensionConfiguration)208  );209}, "resolveRuntimeExtensions");210 211// src/NeptunedataClient.ts212var NeptunedataClient = class extends import_smithy_client.Client {213  static {214    __name(this, "NeptunedataClient");215  }216  /**217   * The resolved configuration of NeptunedataClient class. This is resolved and normalized from the {@link NeptunedataClientConfig | constructor configuration interface}.218   */219  config;220  constructor(...[configuration]) {221    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});222    super(_config_0);223    this.initConfig = _config_0;224    const _config_1 = resolveClientEndpointParameters(_config_0);225    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);226    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);227    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);228    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);229    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);230    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);231    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);232    this.config = _config_8;233    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));234    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));235    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));236    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));237    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));238    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));239    this.middlewareStack.use(240      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {241        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultNeptunedataHttpAuthSchemeParametersProvider,242        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({243          "aws.auth#sigv4": config.credentials244        }), "identityProviderConfigProvider")245      })246    );247    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));248  }249  /**250   * Destroy underlying resources, like sockets. It's usually not necessary to do this.251   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.252   * Otherwise, sockets might stay open for quite a long time before the server terminates them.253   */254  destroy() {255    super.destroy();256  }257};258 259// src/Neptunedata.ts260 261 262// src/commands/CancelGremlinQueryCommand.ts263 264var import_middleware_serde = require("@smithy/middleware-serde");265 266 267// src/protocols/Aws_restJson1.ts268var import_core2 = require("@aws-sdk/core");269 270 271 272// src/models/NeptunedataServiceException.ts273 274var NeptunedataServiceException = class _NeptunedataServiceException extends import_smithy_client.ServiceException {275  static {276    __name(this, "NeptunedataServiceException");277  }278  /**279   * @internal280   */281  constructor(options) {282    super(options);283    Object.setPrototypeOf(this, _NeptunedataServiceException.prototype);284  }285};286 287// src/models/models_0.ts288var AccessDeniedException = class _AccessDeniedException extends NeptunedataServiceException {289  static {290    __name(this, "AccessDeniedException");291  }292  name = "AccessDeniedException";293  $fault = "client";294  /**295   * <p>A detailed message describing the problem.</p>296   * @public297   */298  detailedMessage;299  /**300   * <p>The ID of the request in question.</p>301   * @public302   */303  requestId;304  /**305   * <p>The HTTP status code returned with the exception.</p>306   * @public307   */308  code;309  /**310   * @internal311   */312  constructor(opts) {313    super({314      name: "AccessDeniedException",315      $fault: "client",316      ...opts317    });318    Object.setPrototypeOf(this, _AccessDeniedException.prototype);319    this.detailedMessage = opts.detailedMessage;320    this.requestId = opts.requestId;321    this.code = opts.code;322  }323};324var Action = {325  INITIALIZE_RESET: "initiateDatabaseReset",326  PERFORM_RESET: "performDatabaseReset"327};328var BadRequestException = class _BadRequestException extends NeptunedataServiceException {329  static {330    __name(this, "BadRequestException");331  }332  name = "BadRequestException";333  $fault = "client";334  /**335   * <p>A detailed message describing the problem.</p>336   * @public337   */338  detailedMessage;339  /**340   * <p>The ID of the bad request.</p>341   * @public342   */343  requestId;344  /**345   * <p>The HTTP status code returned with the exception.</p>346   * @public347   */348  code;349  /**350   * @internal351   */352  constructor(opts) {353    super({354      name: "BadRequestException",355      $fault: "client",356      ...opts357    });358    Object.setPrototypeOf(this, _BadRequestException.prototype);359    this.detailedMessage = opts.detailedMessage;360    this.requestId = opts.requestId;361    this.code = opts.code;362  }363};364var ClientTimeoutException = class _ClientTimeoutException extends NeptunedataServiceException {365  static {366    __name(this, "ClientTimeoutException");367  }368  name = "ClientTimeoutException";369  $fault = "client";370  $retryable = {};371  /**372   * <p>A detailed message describing the problem.</p>373   * @public374   */375  detailedMessage;376  /**377   * <p>The ID of the request in question.</p>378   * @public379   */380  requestId;381  /**382   * <p>The HTTP status code returned with the exception.</p>383   * @public384   */385  code;386  /**387   * @internal388   */389  constructor(opts) {390    super({391      name: "ClientTimeoutException",392      $fault: "client",393      ...opts394    });395    Object.setPrototypeOf(this, _ClientTimeoutException.prototype);396    this.detailedMessage = opts.detailedMessage;397    this.requestId = opts.requestId;398    this.code = opts.code;399  }400};401var ConcurrentModificationException = class _ConcurrentModificationException extends NeptunedataServiceException {402  static {403    __name(this, "ConcurrentModificationException");404  }405  name = "ConcurrentModificationException";406  $fault = "server";407  $retryable = {};408  /**409   * <p>A detailed message describing the problem.</p>410   * @public411   */412  detailedMessage;413  /**414   * <p>The ID of the request in question.</p>415   * @public416   */417  requestId;418  /**419   * <p>The HTTP status code returned with the exception.</p>420   * @public421   */422  code;423  /**424   * @internal425   */426  constructor(opts) {427    super({428      name: "ConcurrentModificationException",429      $fault: "server",430      ...opts431    });432    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);433    this.detailedMessage = opts.detailedMessage;434    this.requestId = opts.requestId;435    this.code = opts.code;436  }437};438var ConstraintViolationException = class _ConstraintViolationException extends NeptunedataServiceException {439  static {440    __name(this, "ConstraintViolationException");441  }442  name = "ConstraintViolationException";443  $fault = "client";444  $retryable = {};445  /**446   * <p>A detailed message describing the problem.</p>447   * @public448   */449  detailedMessage;450  /**451   * <p>The ID of the request in question.</p>452   * @public453   */454  requestId;455  /**456   * <p>The HTTP status code returned with the exception.</p>457   * @public458   */459  code;460  /**461   * @internal462   */463  constructor(opts) {464    super({465      name: "ConstraintViolationException",466      $fault: "client",467      ...opts468    });469    Object.setPrototypeOf(this, _ConstraintViolationException.prototype);470    this.detailedMessage = opts.detailedMessage;471    this.requestId = opts.requestId;472    this.code = opts.code;473  }474};475var FailureByQueryException = class _FailureByQueryException extends NeptunedataServiceException {476  static {477    __name(this, "FailureByQueryException");478  }479  name = "FailureByQueryException";480  $fault = "server";481  $retryable = {};482  /**483   * <p>A detailed message describing the problem.</p>484   * @public485   */486  detailedMessage;487  /**488   * <p>The ID of the request in question.</p>489   * @public490   */491  requestId;492  /**493   * <p>The HTTP status code returned with the exception.</p>494   * @public495   */496  code;497  /**498   * @internal499   */500  constructor(opts) {501    super({502      name: "FailureByQueryException",503      $fault: "server",504      ...opts505    });506    Object.setPrototypeOf(this, _FailureByQueryException.prototype);507    this.detailedMessage = opts.detailedMessage;508    this.requestId = opts.requestId;509    this.code = opts.code;510  }511};512var IllegalArgumentException = class _IllegalArgumentException extends NeptunedataServiceException {513  static {514    __name(this, "IllegalArgumentException");515  }516  name = "IllegalArgumentException";517  $fault = "client";518  /**519   * <p>A detailed message describing the problem.</p>520   * @public521   */522  detailedMessage;523  /**524   * <p>The ID of the request in question.</p>525   * @public526   */527  requestId;528  /**529   * <p>The HTTP status code returned with the exception.</p>530   * @public531   */532  code;533  /**534   * @internal535   */536  constructor(opts) {537    super({538      name: "IllegalArgumentException",539      $fault: "client",540      ...opts541    });542    Object.setPrototypeOf(this, _IllegalArgumentException.prototype);543    this.detailedMessage = opts.detailedMessage;544    this.requestId = opts.requestId;545    this.code = opts.code;546  }547};548var InvalidArgumentException = class _InvalidArgumentException extends NeptunedataServiceException {549  static {550    __name(this, "InvalidArgumentException");551  }552  name = "InvalidArgumentException";553  $fault = "client";554  /**555   * <p>A detailed message describing the problem.</p>556   * @public557   */558  detailedMessage;559  /**560   * <p>The ID of the request in question.</p>561   * @public562   */563  requestId;564  /**565   * <p>The HTTP status code returned with the exception.</p>566   * @public567   */568  code;569  /**570   * @internal571   */572  constructor(opts) {573    super({574      name: "InvalidArgumentException",575      $fault: "client",576      ...opts577    });578    Object.setPrototypeOf(this, _InvalidArgumentException.prototype);579    this.detailedMessage = opts.detailedMessage;580    this.requestId = opts.requestId;581    this.code = opts.code;582  }583};584var InvalidParameterException = class _InvalidParameterException extends NeptunedataServiceException {585  static {586    __name(this, "InvalidParameterException");587  }588  name = "InvalidParameterException";589  $fault = "client";590  /**591   * <p>A detailed message describing the problem.</p>592   * @public593   */594  detailedMessage;595  /**596   * <p>The ID of the request that includes an invalid parameter.</p>597   * @public598   */599  requestId;600  /**601   * <p>The HTTP status code returned with the exception.</p>602   * @public603   */604  code;605  /**606   * @internal607   */608  constructor(opts) {609    super({610      name: "InvalidParameterException",611      $fault: "client",612      ...opts613    });614    Object.setPrototypeOf(this, _InvalidParameterException.prototype);615    this.detailedMessage = opts.detailedMessage;616    this.requestId = opts.requestId;617    this.code = opts.code;618  }619};620var MissingParameterException = class _MissingParameterException extends NeptunedataServiceException {621  static {622    __name(this, "MissingParameterException");623  }624  name = "MissingParameterException";625  $fault = "client";626  /**627   * <p>A detailed message describing the problem.</p>628   * @public629   */630  detailedMessage;631  /**632   * <p>The ID of the request in which the parameter is missing.</p>633   * @public634   */635  requestId;636  /**637   * <p>The HTTP status code returned with the exception.</p>638   * @public639   */640  code;641  /**642   * @internal643   */644  constructor(opts) {645    super({646      name: "MissingParameterException",647      $fault: "client",648      ...opts649    });650    Object.setPrototypeOf(this, _MissingParameterException.prototype);651    this.detailedMessage = opts.detailedMessage;652    this.requestId = opts.requestId;653    this.code = opts.code;654  }655};656var ParsingException = class _ParsingException extends NeptunedataServiceException {657  static {658    __name(this, "ParsingException");659  }660  name = "ParsingException";661  $fault = "client";662  /**663   * <p>A detailed message describing the problem.</p>664   * @public665   */666  detailedMessage;667  /**668   * <p>The ID of the request in question.</p>669   * @public670   */671  requestId;672  /**673   * <p>The HTTP status code returned with the exception.</p>674   * @public675   */676  code;677  /**678   * @internal679   */680  constructor(opts) {681    super({682      name: "ParsingException",683      $fault: "client",684      ...opts685    });686    Object.setPrototypeOf(this, _ParsingException.prototype);687    this.detailedMessage = opts.detailedMessage;688    this.requestId = opts.requestId;689    this.code = opts.code;690  }691};692var PreconditionsFailedException = class _PreconditionsFailedException extends NeptunedataServiceException {693  static {694    __name(this, "PreconditionsFailedException");695  }696  name = "PreconditionsFailedException";697  $fault = "client";698  /**699   * <p>A detailed message describing the problem.</p>700   * @public701   */702  detailedMessage;703  /**704   * <p>The ID of the request in question.</p>705   * @public706   */707  requestId;708  /**709   * <p>The HTTP status code returned with the exception.</p>710   * @public711   */712  code;713  /**714   * @internal715   */716  constructor(opts) {717    super({718      name: "PreconditionsFailedException",719      $fault: "client",720      ...opts721    });722    Object.setPrototypeOf(this, _PreconditionsFailedException.prototype);723    this.detailedMessage = opts.detailedMessage;724    this.requestId = opts.requestId;725    this.code = opts.code;726  }727};728var TimeLimitExceededException = class _TimeLimitExceededException extends NeptunedataServiceException {729  static {730    __name(this, "TimeLimitExceededException");731  }732  name = "TimeLimitExceededException";733  $fault = "server";734  $retryable = {};735  /**736   * <p>A detailed message describing the problem.</p>737   * @public738   */739  detailedMessage;740  /**741   * <p>The ID of the request that could not be processed for this reason.</p>742   * @public743   */744  requestId;745  /**746   * <p>The HTTP status code returned with the exception.</p>747   * @public748   */749  code;750  /**751   * @internal752   */753  constructor(opts) {754    super({755      name: "TimeLimitExceededException",756      $fault: "server",757      ...opts758    });759    Object.setPrototypeOf(this, _TimeLimitExceededException.prototype);760    this.detailedMessage = opts.detailedMessage;761    this.requestId = opts.requestId;762    this.code = opts.code;763  }764};765var TooManyRequestsException = class _TooManyRequestsException extends NeptunedataServiceException {766  static {767    __name(this, "TooManyRequestsException");768  }769  name = "TooManyRequestsException";770  $fault = "client";771  $retryable = {};772  /**773   * <p>A detailed message describing the problem.</p>774   * @public775   */776  detailedMessage;777  /**778   * <p>The ID of the request that could not be processed for this reason.</p>779   * @public780   */781  requestId;782  /**783   * <p>The HTTP status code returned with the exception.</p>784   * @public785   */786  code;787  /**788   * @internal789   */790  constructor(opts) {791    super({792      name: "TooManyRequestsException",793      $fault: "client",794      ...opts795    });796    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);797    this.detailedMessage = opts.detailedMessage;798    this.requestId = opts.requestId;799    this.code = opts.code;800  }801};802var UnsupportedOperationException = class _UnsupportedOperationException extends NeptunedataServiceException {803  static {804    __name(this, "UnsupportedOperationException");805  }806  name = "UnsupportedOperationException";807  $fault = "client";808  /**809   * <p>A detailed message describing the problem.</p>810   * @public811   */812  detailedMessage;813  /**814   * <p>The ID of the request in question.</p>815   * @public816   */817  requestId;818  /**819   * <p>The HTTP status code returned with the exception.</p>820   * @public821   */822  code;823  /**824   * @internal825   */826  constructor(opts) {827    super({828      name: "UnsupportedOperationException",829      $fault: "client",830      ...opts831    });832    Object.setPrototypeOf(this, _UnsupportedOperationException.prototype);833    this.detailedMessage = opts.detailedMessage;834    this.requestId = opts.requestId;835    this.code = opts.code;836  }837};838var BulkLoadIdNotFoundException = class _BulkLoadIdNotFoundException extends NeptunedataServiceException {839  static {840    __name(this, "BulkLoadIdNotFoundException");841  }842  name = "BulkLoadIdNotFoundException";843  $fault = "client";844  $retryable = {};845  /**846   * <p>A detailed message describing the problem.</p>847   * @public848   */849  detailedMessage;850  /**851   * <p>The bulk-load job ID that could not be found.</p>852   * @public853   */854  requestId;855  /**856   * <p>The HTTP status code returned with the exception.</p>857   * @public858   */859  code;860  /**861   * @internal862   */863  constructor(opts) {864    super({865      name: "BulkLoadIdNotFoundException",866      $fault: "client",867      ...opts868    });869    Object.setPrototypeOf(this, _BulkLoadIdNotFoundException.prototype);870    this.detailedMessage = opts.detailedMessage;871    this.requestId = opts.requestId;872    this.code = opts.code;873  }874};875var InternalFailureException = class _InternalFailureException extends NeptunedataServiceException {876  static {877    __name(this, "InternalFailureException");878  }879  name = "InternalFailureException";880  $fault = "server";881  /**882   * <p>A detailed message describing the problem.</p>883   * @public884   */885  detailedMessage;886  /**887   * <p>The ID of the request in question.</p>888   * @public889   */890  requestId;891  /**892   * <p>The HTTP status code returned with the exception.</p>893   * @public894   */895  code;896  /**897   * @internal898   */899  constructor(opts) {900    super({901      name: "InternalFailureException",902      $fault: "server",903      ...opts904    });905    Object.setPrototypeOf(this, _InternalFailureException.prototype);906    this.detailedMessage = opts.detailedMessage;907    this.requestId = opts.requestId;908    this.code = opts.code;909  }910};911var LoadUrlAccessDeniedException = class _LoadUrlAccessDeniedException extends NeptunedataServiceException {912  static {913    __name(this, "LoadUrlAccessDeniedException");914  }915  name = "LoadUrlAccessDeniedException";916  $fault = "client";917  /**918   * <p>A detailed message describing the problem.</p>919   * @public920   */921  detailedMessage;922  /**923   * <p>The ID of the request in question.</p>924   * @public925   */926  requestId;927  /**928   * <p>The HTTP status code returned with the exception.</p>929   * @public930   */931  code;932  /**933   * @internal934   */935  constructor(opts) {936    super({937      name: "LoadUrlAccessDeniedException",938      $fault: "client",939      ...opts940    });941    Object.setPrototypeOf(this, _LoadUrlAccessDeniedException.prototype);942    this.detailedMessage = opts.detailedMessage;943    this.requestId = opts.requestId;944    this.code = opts.code;945  }946};947var MLResourceNotFoundException = class _MLResourceNotFoundException extends NeptunedataServiceException {948  static {949    __name(this, "MLResourceNotFoundException");950  }951  name = "MLResourceNotFoundException";952  $fault = "client";953  /**954   * <p>A detailed message describing the problem.</p>955   * @public956   */957  detailedMessage;958  /**959   * <p>The ID of the request in question.</p>960   * @public961   */962  requestId;963  /**964   * <p>The HTTP status code returned with the exception.</p>965   * @public966   */967  code;968  /**969   * @internal970   */971  constructor(opts) {972    super({973      name: "MLResourceNotFoundException",974      $fault: "client",975      ...opts976    });977    Object.setPrototypeOf(this, _MLResourceNotFoundException.prototype);978    this.detailedMessage = opts.detailedMessage;979    this.requestId = opts.requestId;980    this.code = opts.code;981  }982};983var InvalidNumericDataException = class _InvalidNumericDataException extends NeptunedataServiceException {984  static {985    __name(this, "InvalidNumericDataException");986  }987  name = "InvalidNumericDataException";988  $fault = "client";989  /**990   * <p>A detailed message describing the problem.</p>991   * @public992   */993  detailedMessage;994  /**995   * <p>The ID of the request in question.</p>996   * @public997   */998  requestId;999  /**1000   * <p>The HTTP status code returned with the exception.</p>1001   * @public1002   */1003  code;1004  /**1005   * @internal1006   */1007  constructor(opts) {1008    super({1009      name: "InvalidNumericDataException",1010      $fault: "client",1011      ...opts1012    });1013    Object.setPrototypeOf(this, _InvalidNumericDataException.prototype);1014    this.detailedMessage = opts.detailedMessage;1015    this.requestId = opts.requestId;1016    this.code = opts.code;1017  }1018};1019var ReadOnlyViolationException = class _ReadOnlyViolationException extends NeptunedataServiceException {1020  static {1021    __name(this, "ReadOnlyViolationException");1022  }1023  name = "ReadOnlyViolationException";1024  $fault = "client";1025  /**1026   * <p>A detailed message describing the problem.</p>1027   * @public1028   */1029  detailedMessage;1030  /**1031   * <p>The ID of the request in which the parameter is missing.</p>1032   * @public1033   */1034  requestId;1035  /**1036   * <p>The HTTP status code returned with the exception.</p>1037   * @public1038   */1039  code;1040  /**1041   * @internal1042   */1043  constructor(opts) {1044    super({1045      name: "ReadOnlyViolationException",1046      $fault: "client",1047      ...opts1048    });1049    Object.setPrototypeOf(this, _ReadOnlyViolationException.prototype);1050    this.detailedMessage = opts.detailedMessage;1051    this.requestId = opts.requestId;1052    this.code = opts.code;1053  }1054};1055var StatisticsNotAvailableException = class _StatisticsNotAvailableException extends NeptunedataServiceException {1056  static {1057    __name(this, "StatisticsNotAvailableException");1058  }1059  name = "StatisticsNotAvailableException";1060  $fault = "client";1061  /**1062   * <p>A detailed message describing the problem.</p>1063   * @public1064   */1065  detailedMessage;1066  /**1067   * <p>The ID of the request in question.</p>1068   * @public1069   */1070  requestId;1071  /**1072   * <p>The HTTP status code returned with the exception.</p>1073   * @public1074   */1075  code;1076  /**1077   * @internal1078   */1079  constructor(opts) {1080    super({1081      name: "StatisticsNotAvailableException",1082      $fault: "client",1083      ...opts1084    });1085    Object.setPrototypeOf(this, _StatisticsNotAvailableException.prototype);1086    this.detailedMessage = opts.detailedMessage;1087    this.requestId = opts.requestId;1088    this.code = opts.code;1089  }1090};1091var MethodNotAllowedException = class _MethodNotAllowedException extends NeptunedataServiceException {1092  static {1093    __name(this, "MethodNotAllowedException");1094  }1095  name = "MethodNotAllowedException";1096  $fault = "client";1097  /**1098   * <p>A detailed message describing the problem.</p>1099   * @public1100   */1101  detailedMessage;1102  /**1103   * <p>The ID of the request in question.</p>1104   * @public1105   */1106  requestId;1107  /**1108   * <p>The HTTP status code returned with the exception.</p>1109   * @public1110   */1111  code;1112  /**1113   * @internal1114   */1115  constructor(opts) {1116    super({1117      name: "MethodNotAllowedException",1118      $fault: "client",1119      ...opts1120    });1121    Object.setPrototypeOf(this, _MethodNotAllowedException.prototype);1122    this.detailedMessage = opts.detailedMessage;1123    this.requestId = opts.requestId;1124    this.code = opts.code;1125  }1126};1127var ServerShutdownException = class _ServerShutdownException extends NeptunedataServiceException {1128  static {1129    __name(this, "ServerShutdownException");1130  }1131  name = "ServerShutdownException";1132  $fault = "server";1133  /**1134   * <p>A detailed message describing the problem.</p>1135   * @public1136   */1137  detailedMessage;1138  /**1139   * <p>The ID of the request in question.</p>1140   * @public1141   */1142  requestId;1143  /**1144   * <p>The HTTP status code returned with the exception.</p>1145   * @public1146   */1147  code;1148  /**1149   * @internal1150   */1151  constructor(opts) {1152    super({1153      name: "ServerShutdownException",1154      $fault: "server",1155      ...opts1156    });1157    Object.setPrototypeOf(this, _ServerShutdownException.prototype);1158    this.detailedMessage = opts.detailedMessage;1159    this.requestId = opts.requestId;1160    this.code = opts.code;1161  }1162};1163var CancelledByUserException = class _CancelledByUserException extends NeptunedataServiceException {1164  static {1165    __name(this, "CancelledByUserException");1166  }1167  name = "CancelledByUserException";1168  $fault = "server";1169  /**1170   * <p>A detailed message describing the problem.</p>1171   * @public1172   */1173  detailedMessage;1174  /**1175   * <p>The ID of the request in question.</p>1176   * @public1177   */1178  requestId;1179  /**1180   * <p>The HTTP status code returned with the exception.</p>1181   * @public1182   */1183  code;1184  /**1185   * @internal1186   */1187  constructor(opts) {1188    super({1189      name: "CancelledByUserException",1190      $fault: "server",1191      ...opts1192    });1193    Object.setPrototypeOf(this, _CancelledByUserException.prototype);1194    this.detailedMessage = opts.detailedMessage;1195    this.requestId = opts.requestId;1196    this.code = opts.code;1197  }1198};1199var MalformedQueryException = class _MalformedQueryException extends NeptunedataServiceException {1200  static {1201    __name(this, "MalformedQueryException");1202  }1203  name = "MalformedQueryException";1204  $fault = "client";1205  /**1206   * <p>A detailed message describing the problem.</p>1207   * @public1208   */1209  detailedMessage;1210  /**1211   * <p>The ID of the malformed query request.</p>1212   * @public1213   */1214  requestId;1215  /**1216   * <p>The HTTP status code returned with the exception.</p>1217   * @public1218   */1219  code;1220  /**1221   * @internal1222   */1223  constructor(opts) {1224    super({1225      name: "MalformedQueryException",1226      $fault: "client",1227      ...opts1228    });1229    Object.setPrototypeOf(this, _MalformedQueryException.prototype);1230    this.detailedMessage = opts.detailedMessage;1231    this.requestId = opts.requestId;1232    this.code = opts.code;1233  }1234};1235var MemoryLimitExceededException = class _MemoryLimitExceededException extends NeptunedataServiceException {1236  static {1237    __name(this, "MemoryLimitExceededException");1238  }1239  name = "MemoryLimitExceededException";1240  $fault = "server";1241  $retryable = {};1242  /**1243   * <p>A detailed message describing the problem.</p>1244   * @public1245   */1246  detailedMessage;1247  /**1248   * <p>The ID of the request that failed.</p>1249   * @public1250   */1251  requestId;1252  /**1253   * <p>The HTTP status code returned with the exception.</p>1254   * @public1255   */1256  code;1257  /**1258   * @internal1259   */1260  constructor(opts) {1261    super({1262      name: "MemoryLimitExceededException",1263      $fault: "server",1264      ...opts1265    });1266    Object.setPrototypeOf(this, _MemoryLimitExceededException.prototype);1267    this.detailedMessage = opts.detailedMessage;1268    this.requestId = opts.requestId;1269    this.code = opts.code;1270  }1271};1272var QueryLimitExceededException = class _QueryLimitExceededException extends NeptunedataServiceException {1273  static {1274    __name(this, "QueryLimitExceededException");1275  }1276  name = "QueryLimitExceededException";1277  $fault = "server";1278  $retryable = {};1279  /**1280   * <p>A detailed message describing the problem.</p>1281   * @public1282   */1283  detailedMessage;1284  /**1285   * <p>The ID of the request which exceeded the limit.</p>1286   * @public1287   */1288  requestId;1289  /**1290   * <p>The HTTP status code returned with the exception.</p>1291   * @public1292   */1293  code;1294  /**1295   * @internal1296   */1297  constructor(opts) {1298    super({1299      name: "QueryLimitExceededException",1300      $fault: "server",1301      ...opts1302    });1303    Object.setPrototypeOf(this, _QueryLimitExceededException.prototype);1304    this.detailedMessage = opts.detailedMessage;1305    this.requestId = opts.requestId;1306    this.code = opts.code;1307  }1308};1309var QueryLimitException = class _QueryLimitException extends NeptunedataServiceException {1310  static {1311    __name(this, "QueryLimitException");1312  }1313  name = "QueryLimitException";1314  $fault = "client";1315  /**1316   * <p>A detailed message describing the problem.</p>1317   * @public1318   */1319  detailedMessage;1320  /**1321   * <p>The ID of the request that exceeded the limit.</p>1322   * @public1323   */1324  requestId;1325  /**1326   * <p>The HTTP status code returned with the exception.</p>1327   * @public1328   */1329  code;1330  /**1331   * @internal1332   */1333  constructor(opts) {1334    super({1335      name: "QueryLimitException",1336      $fault: "client",1337      ...opts1338    });1339    Object.setPrototypeOf(this, _QueryLimitException.prototype);1340    this.detailedMessage = opts.detailedMessage;1341    this.requestId = opts.requestId;1342    this.code = opts.code;1343  }1344};1345var QueryTooLargeException = class _QueryTooLargeException extends NeptunedataServiceException {1346  static {1347    __name(this, "QueryTooLargeException");1348  }1349  name = "QueryTooLargeException";1350  $fault = "client";1351  /**1352   * <p>A detailed message describing the problem.</p>1353   * @public1354   */1355  detailedMessage;1356  /**1357   * <p>The ID of the request that is too large.</p>1358   * @public1359   */1360  requestId;1361  /**1362   * <p>The HTTP status code returned with the exception.</p>1363   * @public1364   */1365  code;1366  /**1367   * @internal1368   */1369  constructor(opts) {1370    super({1371      name: "QueryTooLargeException",1372      $fault: "client",1373      ...opts1374    });1375    Object.setPrototypeOf(this, _QueryTooLargeException.prototype);1376    this.detailedMessage = opts.detailedMessage;1377    this.requestId = opts.requestId;1378    this.code = opts.code;1379  }1380};1381var OpenCypherExplainMode = {1382  DETAILS: "details",1383  DYNAMIC: "dynamic",1384  STATIC: "static"1385};1386var ExpiredStreamException = class _ExpiredStreamException extends NeptunedataServiceException {1387  static {1388    __name(this, "ExpiredStreamException");1389  }1390  name = "ExpiredStreamException";1391  $fault = "client";1392  /**1393   * <p>A detailed message describing the problem.</p>1394   * @public1395   */1396  detailedMessage;1397  /**1398   * <p>The ID of the request in question.</p>1399   * @public1400   */1401  requestId;1402  /**1403   * <p>The HTTP status code returned with the exception.</p>1404   * @public1405   */1406  code;1407  /**1408   * @internal1409   */1410  constructor(opts) {1411    super({1412      name: "ExpiredStreamException",1413      $fault: "client",1414      ...opts1415    });1416    Object.setPrototypeOf(this, _ExpiredStreamException.prototype);1417    this.detailedMessage = opts.detailedMessage;1418    this.requestId = opts.requestId;1419    this.code = opts.code;1420  }1421};1422var Encoding = {1423  GZIP: "gzip"1424};1425var IteratorType = {1426  AFTER_SEQUENCE_NUMBER: "AFTER_SEQUENCE_NUMBER",1427  AT_SEQUENCE_NUMBER: "AT_SEQUENCE_NUMBER",1428  LATEST: "LATEST",1429  TRIM_HORIZON: "TRIM_HORIZON"1430};1431var StreamRecordsNotFoundException = class _StreamRecordsNotFoundException extends NeptunedataServiceException {1432  static {1433    __name(this, "StreamRecordsNotFoundException");1434  }1435  name = "StreamRecordsNotFoundException";1436  $fault = "client";1437  /**1438   * <p>A detailed message describing the problem.</p>1439   * @public1440   */1441  detailedMessage;1442  /**1443   * <p>The ID of the request in question.</p>1444   * @public1445   */1446  requestId;1447  /**1448   * <p>The HTTP status code returned with the exception.</p>1449   * @public1450   */1451  code;1452  /**1453   * @internal1454   */1455  constructor(opts) {1456    super({1457      name: "StreamRecordsNotFoundException",1458      $fault: "client",1459      ...opts1460    });1461    Object.setPrototypeOf(this, _StreamRecordsNotFoundException.prototype);1462    this.detailedMessage = opts.detailedMessage;1463    this.requestId = opts.requestId;1464    this.code = opts.code;1465  }1466};1467var ThrottlingException = class _ThrottlingException extends NeptunedataServiceException {1468  static {1469    __name(this, "ThrottlingException");1470  }1471  name = "ThrottlingException";1472  $fault = "server";1473  $retryable = {};1474  /**1475   * <p>A detailed message describing the problem.</p>1476   * @public1477   */1478  detailedMessage;1479  /**1480   * <p>The ID of the request that could not be processed for this reason.</p>1481   * @public1482   */1483  requestId;1484  /**1485   * <p>The HTTP status code returned with the exception.</p>1486   * @public1487   */1488  code;1489  /**1490   * @internal1491   */1492  constructor(opts) {1493    super({1494      name: "ThrottlingException",1495      $fault: "server",1496      ...opts1497    });1498    Object.setPrototypeOf(this, _ThrottlingException.prototype);1499    this.detailedMessage = opts.detailedMessage;1500    this.requestId = opts.requestId;1501    this.code = opts.code;1502  }1503};1504var GraphSummaryType = {1505  BASIC: "basic",1506  DETAILED: "detailed"1507};1508var StatisticsAutoGenerationMode = {1509  DISABLE_AUTOCOMPUTE: "disableAutoCompute",1510  ENABLE_AUTOCOMPUTE: "enableAutoCompute",1511  REFRESH: "refresh"1512};1513var S3Exception = class _S3Exception extends NeptunedataServiceException {1514  static {1515    __name(this, "S3Exception");1516  }1517  name = "S3Exception";1518  $fault = "client";1519  $retryable = {};1520  /**1521   * <p>A detailed message describing the problem.</p>1522   * @public1523   */1524  detailedMessage;1525  /**1526   * <p>The ID of the request in question.</p>1527   * @public1528   */1529  requestId;1530  /**1531   * <p>The HTTP status code returned with the exception.</p>1532   * @public1533   */1534  code;1535  /**1536   * @internal1537   */1538  constructor(opts) {1539    super({1540      name: "S3Exception",1541      $fault: "client",1542      ...opts1543    });1544    Object.setPrototypeOf(this, _S3Exception.prototype);1545    this.detailedMessage = opts.detailedMessage;1546    this.requestId = opts.requestId;1547    this.code = opts.code;1548  }1549};1550var Format = {1551  CSV: "csv",1552  NQUADS: "nquads",1553  NTRIPLES: "ntriples",1554  OPENCYPHER: "opencypher",1555  RDFXML: "rdfxml",1556  TURTLE: "turtle"1557};1558var Mode = {1559  AUTO: "AUTO",1560  NEW: "NEW",1561  RESUME: "RESUME"1562};1563var Parallelism = {1564  HIGH: "HIGH",1565  LOW: "LOW",1566  MEDIUM: "MEDIUM",1567  OVERSUBSCRIBE: "OVERSUBSCRIBE"1568};1569var S3BucketRegion = {1570  AF_SOUTH_1: "af-south-1",1571  AP_EAST_1: "ap-east-1",1572  AP_EAST_2: "ap-east-2",1573  AP_NORTHEAST_1: "ap-northeast-1",1574  AP_NORTHEAST_2: "ap-northeast-2",1575  AP_NORTHEAST_3: "ap-northeast-3",1576  AP_SOUTHEAST_1: "ap-southeast-1",1577  AP_SOUTHEAST_2: "ap-southeast-2",1578  AP_SOUTHEAST_3: "ap-southeast-3",1579  AP_SOUTHEAST_4: "ap-southeast-4",1580  AP_SOUTHEAST_5: "ap-southeast-5",1581  AP_SOUTHEAST_7: "ap-southeast-7",1582  AP_SOUTH_1: "ap-south-1",1583  AP_SOUTH_2: "ap-south-2",1584  CA_CENTRAL_1: "ca-central-1",1585  CA_WEST_1: "ca-west-1",1586  CN_NORTHWEST_1: "cn-northwest-1",1587  CN_NORTH_1: "cn-north-1",1588  EU_CENTRAL_1: "eu-central-1",1589  EU_CENTRAL_2: "eu-central-2",1590  EU_NORTH_1: "eu-north-1",1591  EU_SOUTH_2: "eu-south-2",1592  EU_WEST_1: "eu-west-1",1593  EU_WEST_2: "eu-west-2",1594  EU_WEST_3: "eu-west-3",1595  IL_CENTRAL_1: "il-central-1",1596  ME_CENTRAL_1: "me-central-1",1597  ME_SOUTH_1: "me-south-1",1598  MX_CENTRAL_1: "mx-central-1",1599  SA_EAST_1: "sa-east-1",1600  US_EAST_1: "us-east-1",1601  US_EAST_2: "us-east-2",1602  US_GOV_EAST_1: "us-gov-east-1",1603  US_GOV_WEST_1: "us-gov-west-1",1604  US_WEST_1: "us-west-1",1605  US_WEST_2: "us-west-2"1606};1607 1608// src/protocols/Aws_restJson1.ts1609var se_CancelGremlinQueryCommand = /* @__PURE__ */ __name(async (input, context) => {1610  const b = (0, import_core.requestBuilder)(input, context);1611  const headers = {};1612  b.bp("/gremlin/status/{queryId}");1613  b.p("queryId", () => input.queryId, "{queryId}", false);1614  let body;1615  b.m("DELETE").h(headers).b(body);1616  return b.build();1617}, "se_CancelGremlinQueryCommand");1618var se_CancelLoaderJobCommand = /* @__PURE__ */ __name(async (input, context) => {1619  const b = (0, import_core.requestBuilder)(input, context);1620  const headers = {};1621  b.bp("/loader/{loadId}");1622  b.p("loadId", () => input.loadId, "{loadId}", false);1623  let body;1624  b.m("DELETE").h(headers).b(body);1625  return b.build();1626}, "se_CancelLoaderJobCommand");1627var se_CancelMLDataProcessingJobCommand = /* @__PURE__ */ __name(async (input, context) => {1628  const b = (0, import_core.requestBuilder)(input, context);1629  const headers = {};1630  b.bp("/ml/dataprocessing/{id}");1631  b.p("id", () => input.id, "{id}", false);1632  const query = (0, import_smithy_client.map)({1633    [_nIRA]: [, input[_nIRA]],1634    [_c]: [() => input.clean !== void 0, () => input[_c].toString()]1635  });1636  let body;1637  b.m("DELETE").h(headers).q(query).b(body);1638  return b.build();1639}, "se_CancelMLDataProcessingJobCommand");1640var se_CancelMLModelTrainingJobCommand = /* @__PURE__ */ __name(async (input, context) => {1641  const b = (0, import_core.requestBuilder)(input, context);1642  const headers = {};1643  b.bp("/ml/modeltraining/{id}");1644  b.p("id", () => input.id, "{id}", false);1645  const query = (0, import_smithy_client.map)({1646    [_nIRA]: [, input[_nIRA]],1647    [_c]: [() => input.clean !== void 0, () => input[_c].toString()]1648  });1649  let body;1650  b.m("DELETE").h(headers).q(query).b(body);1651  return b.build();1652}, "se_CancelMLModelTrainingJobCommand");1653var se_CancelMLModelTransformJobCommand = /* @__PURE__ */ __name(async (input, context) => {1654  const b = (0, import_core.requestBuilder)(input, context);1655  const headers = {};1656  b.bp("/ml/modeltransform/{id}");1657  b.p("id", () => input.id, "{id}", false);1658  const query = (0, import_smithy_client.map)({1659    [_nIRA]: [, input[_nIRA]],1660    [_c]: [() => input.clean !== void 0, () => input[_c].toString()]1661  });1662  let body;1663  b.m("DELETE").h(headers).q(query).b(body);1664  return b.build();1665}, "se_CancelMLModelTransformJobCommand");1666var se_CancelOpenCypherQueryCommand = /* @__PURE__ */ __name(async (input, context) => {1667  const b = (0, import_core.requestBuilder)(input, context);1668  const headers = {};1669  b.bp("/opencypher/status/{queryId}");1670  b.p("queryId", () => input.queryId, "{queryId}", false);1671  const query = (0, import_smithy_client.map)({1672    [_s]: [() => input.silent !== void 0, () => input[_s].toString()]1673  });1674  let body;1675  b.m("DELETE").h(headers).q(query).b(body);1676  return b.build();1677}, "se_CancelOpenCypherQueryCommand");1678var se_CreateMLEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {1679  const b = (0, import_core.requestBuilder)(input, context);1680  const headers = {1681    "content-type": "application/json"1682  };1683  b.bp("/ml/endpoints");1684  let body;1685  body = JSON.stringify(1686    (0, import_smithy_client.take)(input, {1687      id: [],1688      instanceCount: [],1689      instanceType: [],1690      mlModelTrainingJobId: [],1691      mlModelTransformJobId: [],1692      modelName: [],1693      neptuneIamRoleArn: [],1694      update: [],1695      volumeEncryptionKMSKey: []1696    })1697  );1698  b.m("POST").h(headers).b(body);1699  return b.build();1700}, "se_CreateMLEndpointCommand");1701var se_DeleteMLEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {1702  const b = (0, import_core.requestBuilder)(input, context);1703  const headers = {};1704  b.bp("/ml/endpoints/{id}");1705  b.p("id", () => input.id, "{id}", false);1706  const query = (0, import_smithy_client.map)({1707    [_nIRA]: [, input[_nIRA]],1708    [_c]: [() => input.clean !== void 0, () => input[_c].toString()]1709  });1710  let body;1711  b.m("DELETE").h(headers).q(query).b(body);1712  return b.build();1713}, "se_DeleteMLEndpointCommand");1714var se_DeletePropertygraphStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {1715  const b = (0, import_core.requestBuilder)(input, context);1716  const headers = {};1717  b.bp("/propertygraph/statistics");1718  let body;1719  b.m("DELETE").h(headers).b(body);1720  return b.build();1721}, "se_DeletePropertygraphStatisticsCommand");1722var se_DeleteSparqlStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {1723  const b = (0, import_core.requestBuilder)(input, context);1724  const headers = {};1725  b.bp("/sparql/statistics");1726  let body;1727  b.m("DELETE").h(headers).b(body);1728  return b.build();1729}, "se_DeleteSparqlStatisticsCommand");1730var se_ExecuteFastResetCommand = /* @__PURE__ */ __name(async (input, context) => {1731  const b = (0, import_core.requestBuilder)(input, context);1732  const headers = {1733    "content-type": "application/json"1734  };1735  b.bp("/system");1736  let body;1737  body = JSON.stringify(1738    (0, import_smithy_client.take)(input, {1739      action: [],1740      token: []1741    })1742  );1743  b.m("POST").h(headers).b(body);1744  return b.build();1745}, "se_ExecuteFastResetCommand");1746var se_ExecuteGremlinExplainQueryCommand = /* @__PURE__ */ __name(async (input, context) => {1747  const b = (0, import_core.requestBuilder)(input, context);1748  const headers = {1749    "content-type": "application/json"1750  };1751  b.bp("/gremlin/explain");1752  let body;1753  body = JSON.stringify(1754    (0, import_smithy_client.take)(input, {1755      gremlin: [, , `gremlinQuery`]1756    })1757  );1758  b.m("POST").h(headers).b(body);1759  return b.build();1760}, "se_ExecuteGremlinExplainQueryCommand");1761var se_ExecuteGremlinProfileQueryCommand = /* @__PURE__ */ __name(async (input, context) => {1762  const b = (0, import_core.requestBuilder)(input, context);1763  const headers = {1764    "content-type": "application/json"1765  };1766  b.bp("/gremlin/profile");1767  let body;1768  body = JSON.stringify(1769    (0, import_smithy_client.take)(input, {1770      "profile.chop": [, , `chop`],1771      gremlin: [, , `gremlinQuery`],1772      "profile.indexOps": [, , `indexOps`],1773      "profile.results": [, , `results`],1774      "profile.serializer": [, , `serializer`]1775    })1776  );1777  b.m("POST").h(headers).b(body);1778  return b.build();1779}, "se_ExecuteGremlinProfileQueryCommand");1780var se_ExecuteGremlinQueryCommand = /* @__PURE__ */ __name(async (input, context) => {1781  const b = (0, import_core.requestBuilder)(input, context);1782  const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {1783    "content-type": "application/json",1784    [_a]: input[_se]1785  });1786  b.bp("/gremlin");1787  let body;1788  body = JSON.stringify(1789    (0, import_smithy_client.take)(input, {1790      gremlin: [, , `gremlinQuery`]1791    })1792  );1793  b.m("POST").h(headers).b(body);1794  return b.build();1795}, "se_ExecuteGremlinQueryCommand");1796var se_ExecuteOpenCypherExplainQueryCommand = /* @__PURE__ */ __name(async (input, context) => {1797  const b = (0, import_core.requestBuilder)(input, context);1798  const headers = {1799    "content-type": "application/json"1800  };1801  b.bp("/opencypher/explain");1802  let body;1803  body = JSON.stringify(1804    (0, import_smithy_client.take)(input, {1805      explain: [, , `explainMode`],1806      query: [, , `openCypherQuery`],1807      parameters: []1808    })1809  );1810  b.m("POST").h(headers).b(body);1811  return b.build();1812}, "se_ExecuteOpenCypherExplainQueryCommand");1813var se_ExecuteOpenCypherQueryCommand = /* @__PURE__ */ __name(async (input, context) => {1814  const b = (0, import_core.requestBuilder)(input, context);1815  const headers = {1816    "content-type": "application/json"1817  };1818  b.bp("/opencypher");1819  let body;1820  body = JSON.stringify(1821    (0, import_smithy_client.take)(input, {1822      query: [, , `openCypherQuery`],1823      parameters: []1824    })1825  );1826  b.m("POST").h(headers).b(body);1827  return b.build();1828}, "se_ExecuteOpenCypherQueryCommand");1829var se_GetEngineStatusCommand = /* @__PURE__ */ __name(async (input, context) => {1830  const b = (0, import_core.requestBuilder)(input, context);1831  const headers = {};1832  b.bp("/status");1833  let body;1834  b.m("GET").h(headers).b(body);1835  return b.build();1836}, "se_GetEngineStatusCommand");1837var se_GetGremlinQueryStatusCommand = /* @__PURE__ */ __name(async (input, context) => {1838  const b = (0, import_core.requestBuilder)(input, context);1839  const headers = {};1840  b.bp("/gremlin/status/{queryId}");1841  b.p("queryId", () => input.queryId, "{queryId}", false);1842  let body;1843  b.m("GET").h(headers).b(body);1844  return b.build();1845}, "se_GetGremlinQueryStatusCommand");1846var se_GetLoaderJobStatusCommand = /* @__PURE__ */ __name(async (input, context) => {1847  const b = (0, import_core.requestBuilder)(input, context);1848  const headers = {};1849  b.bp("/loader/{loadId}");1850  b.p("loadId", () => input.loadId, "{loadId}", false);1851  const query = (0, import_smithy_client.map)({1852    [_d]: [() => input.details !== void 0, () => input[_d].toString()],1853    [_e]: [() => input.errors !== void 0, () => input[_e].toString()],1854    [_p]: [() => input.page !== void 0, () => input[_p].toString()],1855    [_ePP]: [() => input.errorsPerPage !== void 0, () => input[_ePP].toString()]1856  });1857  let body;1858  b.m("GET").h(headers).q(query).b(body);1859  return b.build();1860}, "se_GetLoaderJobStatusCommand");1861var se_GetMLDataProcessingJobCommand = /* @__PURE__ */ __name(async (input, context) => {1862  const b = (0, import_core.requestBuilder)(input, context);1863  const headers = {};1864  b.bp("/ml/dataprocessing/{id}");1865  b.p("id", () => input.id, "{id}", false);1866  const query = (0, import_smithy_client.map)({1867    [_nIRA]: [, input[_nIRA]]1868  });1869  let body;1870  b.m("GET").h(headers).q(query).b(body);1871  return b.build();1872}, "se_GetMLDataProcessingJobCommand");1873var se_GetMLEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {1874  const b = (0, import_core.requestBuilder)(input, context);1875  const headers = {};1876  b.bp("/ml/endpoints/{id}");1877  b.p("id", () => input.id, "{id}", false);1878  const query = (0, import_smithy_client.map)({1879    [_nIRA]: [, input[_nIRA]]1880  });1881  let body;1882  b.m("GET").h(headers).q(query).b(body);1883  return b.build();1884}, "se_GetMLEndpointCommand");1885var se_GetMLModelTrainingJobCommand = /* @__PURE__ */ __name(async (input, context) => {1886  const b = (0, import_core.requestBuilder)(input, context);1887  const headers = {};1888  b.bp("/ml/modeltraining/{id}");1889  b.p("id", () => input.id, "{id}", false);1890  const query = (0, import_smithy_client.map)({1891    [_nIRA]: [, input[_nIRA]]1892  });1893  let body;1894  b.m("GET").h(headers).q(query).b(body);1895  return b.build();1896}, "se_GetMLModelTrainingJobCommand");1897var se_GetMLModelTransformJobCommand = /* @__PURE__ */ __name(async (input, context) => {1898  const b = (0, import_core.requestBuilder)(input, context);1899  const headers = {};1900  b.bp("/ml/modeltransform/{id}");1901  b.p("id", () => input.id, "{id}", false);1902  const query = (0, import_smithy_client.map)({1903    [_nIRA]: [, input[_nIRA]]1904  });1905  let body;1906  b.m("GET").h(headers).q(query).b(body);1907  return b.build();1908}, "se_GetMLModelTransformJobCommand");1909var se_GetOpenCypherQueryStatusCommand = /* @__PURE__ */ __name(async (input, context) => {1910  const b = (0, import_core.requestBuilder)(input, context);1911  const headers = {};1912  b.bp("/opencypher/status/{queryId}");1913  b.p("queryId", () => input.queryId, "{queryId}", false);1914  let body;1915  b.m("GET").h(headers).b(body);1916  return b.build();1917}, "se_GetOpenCypherQueryStatusCommand");1918var se_GetPropertygraphStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {1919  const b = (0, import_core.requestBuilder)(input, context);1920  const headers = {};1921  b.bp("/propertygraph/statistics");1922  let body;1923  b.m("GET").h(headers).b(body);1924  return b.build();1925}, "se_GetPropertygraphStatisticsCommand");1926var se_GetPropertygraphStreamCommand = /* @__PURE__ */ __name(async (input, context) => {1927  const b = (0, import_core.requestBuilder)(input, context);1928  const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {1929    [_ae]: input[_en]1930  });1931  b.bp("/propertygraph/stream");1932  const query = (0, import_smithy_client.map)({1933    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],1934    [_iT]: [, input[_iT]],1935    [_cN]: [() => input.commitNum !== void 0, () => input[_cN].toString()],1936    [_oN]: [() => input.opNum !== void 0, () => input[_oN].toString()]1937  });1938  let body;1939  b.m("GET").h(headers).q(query).b(body);1940  return b.build();1941}, "se_GetPropertygraphStreamCommand");1942var se_GetPropertygraphSummaryCommand = /* @__PURE__ */ __name(async (input, context) => {1943  const b = (0, import_core.requestBuilder)(input, context);1944  const headers = {};1945  b.bp("/propertygraph/statistics/summary");1946  const query = (0, import_smithy_client.map)({1947    [_m]: [, input[_m]]1948  });1949  let body;1950  b.m("GET").h(headers).q(query).b(body);1951  return b.build();1952}, "se_GetPropertygraphSummaryCommand");1953var se_GetRDFGraphSummaryCommand = /* @__PURE__ */ __name(async (input, context) => {1954  const b = (0, import_core.requestBuilder)(input, context);1955  const headers = {};1956  b.bp("/rdf/statistics/summary");1957  const query = (0, import_smithy_client.map)({1958    [_m]: [, input[_m]]1959  });1960  let body;1961  b.m("GET").h(headers).q(query).b(body);1962  return b.build();1963}, "se_GetRDFGraphSummaryCommand");1964var se_GetSparqlStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {1965  const b = (0, import_core.requestBuilder)(input, context);1966  const headers = {};1967  b.bp("/sparql/statistics");1968  let body;1969  b.m("GET").h(headers).b(body);1970  return b.build();1971}, "se_GetSparqlStatisticsCommand");1972var se_GetSparqlStreamCommand = /* @__PURE__ */ __name(async (input, context) => {1973  const b = (0, import_core.requestBuilder)(input, context);1974  const headers = (0, import_smithy_client.map)({}, import_smithy_client.isSerializableHeaderValue, {1975    [_ae]: input[_en]1976  });1977  b.bp("/sparql/stream");1978  const query = (0, import_smithy_client.map)({1979    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],1980    [_iT]: [, input[_iT]],1981    [_cN]: [() => input.commitNum !== void 0, () => input[_cN].toString()],1982    [_oN]: [() => input.opNum !== void 0, () => input[_oN].toString()]1983  });1984  let body;1985  b.m("GET").h(headers).q(query).b(body);1986  return b.build();1987}, "se_GetSparqlStreamCommand");1988var se_ListGremlinQueriesCommand = /* @__PURE__ */ __name(async (input, context) => {1989  const b = (0, import_core.requestBuilder)(input, context);1990  const headers = {};1991  b.bp("/gremlin/status");1992  const query = (0, import_smithy_client.map)({1993    [_iW]: [() => input.includeWaiting !== void 0, () => input[_iW].toString()]1994  });1995  let body;1996  b.m("GET").h(headers).q(query).b(body);1997  return b.build();1998}, "se_ListGremlinQueriesCommand");1999var se_ListLoaderJobsCommand = /* @__PURE__ */ __name(async (input, context) => {2000  const b = (0, import_core.requestBuilder)(input, context);2001  const headers = {};2002  b.bp("/loader");2003  const query = (0, import_smithy_client.map)({2004    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],2005    [_iQL]: [() => input.includeQueuedLoads !== void 0, () => input[_iQL].toString()]2006  });2007  let body;2008  b.m("GET").h(headers).q(query).b(body);2009  return b.build();2010}, "se_ListLoaderJobsCommand");2011var se_ListMLDataProcessingJobsCommand = /* @__PURE__ */ __name(async (input, context) => {2012  const b = (0, import_core.requestBuilder)(input, context);2013  const headers = {};2014  b.bp("/ml/dataprocessing");2015  const query = (0, import_smithy_client.map)({2016    [_mI]: [() => input.maxItems !== void 0, () => input[_mI].toString()],2017    [_nIRA]: [, input[_nIRA]]2018  });2019  let body;2020  b.m("GET").h(headers).q(query).b(body);2021  return b.build();2022}, "se_ListMLDataProcessingJobsCommand");2023var se_ListMLEndpointsCommand = /* @__PURE__ */ __name(async (input, context) => {2024  const b = (0, import_core.requestBuilder)(input, context);2025  const headers = {};2026  b.bp("/ml/endpoints");2027  const query = (0, import_smithy_client.map)({2028    [_mI]: [() => input.maxItems !== void 0, () => input[_mI].toString()],2029    [_nIRA]: [, input[_nIRA]]2030  });2031  let body;2032  b.m("GET").h(headers).q(query).b(body);2033  return b.build();2034}, "se_ListMLEndpointsCommand");2035var se_ListMLModelTrainingJobsCommand = /* @__PURE__ */ __name(async (input, context) => {2036  const b = (0, import_core.requestBuilder)(input, context);2037  const headers = {};2038  b.bp("/ml/modeltraining");2039  const query = (0, import_smithy_client.map)({2040    [_mI]: [() => input.maxItems !== void 0, () => input[_mI].toString()],2041    [_nIRA]: [, input[_nIRA]]2042  });2043  let body;2044  b.m("GET").h(headers).q(query).b(body);2045  return b.build();2046}, "se_ListMLModelTrainingJobsCommand");2047var se_ListMLModelTransformJobsCommand = /* @__PURE__ */ __name(async (input, context) => {2048  const b = (0, import_core.requestBuilder)(input, context);2049  const headers = {};2050  b.bp("/ml/modeltransform");2051  const query = (0, import_smithy_client.map)({2052    [_mI]: [() => input.maxItems !== void 0, () => input[_mI].toString()],2053    [_nIRA]: [, input[_nIRA]]2054  });2055  let body;2056  b.m("GET").h(headers).q(query).b(body);2057  return b.build();2058}, "se_ListMLModelTransformJobsCommand");2059var se_ListOpenCypherQueriesCommand = /* @__PURE__ */ __name(async (input, context) => {2060  const b = (0, import_core.requestBuilder)(input, context);2061  const headers = {};2062  b.bp("/opencypher/status");2063  const query = (0, import_smithy_client.map)({2064    [_iW]: [() => input.includeWaiting !== void 0, () => input[_iW].toString()]2065  });2066  let body;2067  b.m("GET").h(headers).q(query).b(body);2068  return b.build();2069}, "se_ListOpenCypherQueriesCommand");2070var se_ManagePropertygraphStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {2071  const b = (0, import_core.requestBuilder)(input, context);2072  const headers = {2073    "content-type": "application/json"2074  };2075  b.bp("/propertygraph/statistics");2076  let body;2077  body = JSON.stringify(2078    (0, import_smithy_client.take)(input, {2079      mode: []2080    })2081  );2082  b.m("POST").h(headers).b(body);2083  return b.build();2084}, "se_ManagePropertygraphStatisticsCommand");2085var se_ManageSparqlStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {2086  const b = (0, import_core.requestBuilder)(input, context);2087  const headers = {2088    "content-type": "application/json"2089  };2090  b.bp("/sparql/statistics");2091  let body;2092  body = JSON.stringify(2093    (0, import_smithy_client.take)(input, {2094      mode: []2095    })2096  );2097  b.m("POST").h(headers).b(body);2098  return b.build();2099}, "se_ManageSparqlStatisticsCommand");2100var se_StartLoaderJobCommand = /* @__PURE__ */ __name(async (input, context) => {2101  const b = (0, import_core.requestBuilder)(input, context);2102  const headers = {2103    "content-type": "application/json"2104  };2105  b.bp("/loader");2106  let body;2107  body = JSON.stringify(2108    (0, import_smithy_client.take)(input, {2109      dependencies: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "dependencies"),2110      failOnError: [],2111      format: [],2112      iamRoleArn: [],2113      mode: [],2114      parallelism: [],2115      parserConfiguration: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "parserConfiguration"),2116      queueRequest: [],2117      region: [, , `s3BucketRegion`],2118      source: [],2119      updateSingleCardinalityProperties: [],2120      userProvidedEdgeIds: []2121    })2122  );2123  b.m("POST").h(headers).b(body);2124  return b.build();2125}, "se_StartLoaderJobCommand");2126var se_StartMLDataProcessingJobCommand = /* @__PURE__ */ __name(async (input, context) => {2127  const b = (0, import_core.requestBuilder)(input, context);2128  const headers = {2129    "content-type": "application/json"2130  };2131  b.bp("/ml/dataprocessing");2132  let body;2133  body = JSON.stringify(2134    (0, import_smithy_client.take)(input, {2135      configFileName: [],2136      id: [],2137      inputDataS3Location: [],2138      modelType: [],2139      neptuneIamRoleArn: [],2140      previousDataProcessingJobId: [],2141      processedDataS3Location: [],2142      processingInstanceType: [],2143      processingInstanceVolumeSizeInGB: [],2144      processingTimeOutInSeconds: [],2145      s3OutputEncryptionKMSKey: [],2146      sagemakerIamRoleArn: [],2147      securityGroupIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "securityGroupIds"),2148      subnets: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "subnets"),2149      volumeEncryptionKMSKey: []2150    })2151  );2152  b.m("POST").h(headers).b(body);2153  return b.build();2154}, "se_StartMLDataProcessingJobCommand");2155var se_StartMLModelTrainingJobCommand = /* @__PURE__ */ __name(async (input, context) => {2156  const b = (0, import_core.requestBuilder)(input, context);2157  const headers = {2158    "content-type": "application/json"2159  };2160  b.bp("/ml/modeltraining");2161  let body;2162  body = JSON.stringify(2163    (0, import_smithy_client.take)(input, {2164      baseProcessingInstanceType: [],2165      customModelTrainingParameters: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "customModelTrainingParameters"),2166      dataProcessingJobId: [],2167      enableManagedSpotTraining: [],2168      id: [],2169      maxHPONumberOfTrainingJobs: [],2170      maxHPOParallelTrainingJobs: [],2171      neptuneIamRoleArn: [],2172      previousModelTrainingJobId: [],2173      s3OutputEncryptionKMSKey: [],2174      sagemakerIamRoleArn: [],2175      securityGroupIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "securityGroupIds"),2176      subnets: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "subnets"),2177      trainModelS3Location: [],2178      trainingInstanceType: [],2179      trainingInstanceVolumeSizeInGB: [],2180      trainingTimeOutInSeconds: [],2181      volumeEncryptionKMSKey: []2182    })2183  );2184  b.m("POST").h(headers).b(body);2185  return b.build();2186}, "se_StartMLModelTrainingJobCommand");2187var se_StartMLModelTransformJobCommand = /* @__PURE__ */ __name(async (input, context) => {2188  const b = (0, import_core.requestBuilder)(input, context);2189  const headers = {2190    "content-type": "application/json"2191  };2192  b.bp("/ml/modeltransform");2193  let body;2194  body = JSON.stringify(2195    (0, import_smithy_client.take)(input, {2196      baseProcessingInstanceType: [],2197      baseProcessingInstanceVolumeSizeInGB: [],2198      customModelTransformParameters: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "customModelTransformParameters"),2199      dataProcessingJobId: [],2200      id: [],2201      mlModelTrainingJobId: [],2202      modelTransformOutputS3Location: [],2203      neptuneIamRoleArn: [],2204      s3OutputEncryptionKMSKey: [],2205      sagemakerIamRoleArn: [],2206      securityGroupIds: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "securityGroupIds"),2207      subnets: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "subnets"),2208      trainingJobName: [],2209      volumeEncryptionKMSKey: []2210    })2211  );2212  b.m("POST").h(headers).b(body);2213  return b.build();2214}, "se_StartMLModelTransformJobCommand");2215var de_CancelGremlinQueryCommand = /* @__PURE__ */ __name(async (output, context) => {2216  if (output.statusCode !== 200 && output.statusCode >= 300) {2217    return de_CommandError(output, context);2218  }2219  const contents = (0, import_smithy_client.map)({2220    $metadata: deserializeMetadata(output)2221  });2222  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2223  const doc = (0, import_smithy_client.take)(data, {2224    status: import_smithy_client.expectString2225  });2226  Object.assign(contents, doc);2227  return contents;2228}, "de_CancelGremlinQueryCommand");2229var de_CancelLoaderJobCommand = /* @__PURE__ */ __name(async (output, context) => {2230  if (output.statusCode !== 200 && output.statusCode >= 300) {2231    return de_CommandError(output, context);2232  }2233  const contents = (0, import_smithy_client.map)({2234    $metadata: deserializeMetadata(output)2235  });2236  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2237  const doc = (0, import_smithy_client.take)(data, {2238    status: import_smithy_client.expectString2239  });2240  Object.assign(contents, doc);2241  return contents;2242}, "de_CancelLoaderJobCommand");2243var de_CancelMLDataProcessingJobCommand = /* @__PURE__ */ __name(async (output, context) => {2244  if (output.statusCode !== 200 && output.statusCode >= 300) {2245    return de_CommandError(output, context);2246  }2247  const contents = (0, import_smithy_client.map)({2248    $metadata: deserializeMetadata(output)2249  });2250  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2251  const doc = (0, import_smithy_client.take)(data, {2252    status: import_smithy_client.expectString2253  });2254  Object.assign(contents, doc);2255  return contents;2256}, "de_CancelMLDataProcessingJobCommand");2257var de_CancelMLModelTrainingJobCommand = /* @__PURE__ */ __name(async (output, context) => {2258  if (output.statusCode !== 200 && output.statusCode >= 300) {2259    return de_CommandError(output, context);2260  }2261  const contents = (0, import_smithy_client.map)({2262    $metadata: deserializeMetadata(output)2263  });2264  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2265  const doc = (0, import_smithy_client.take)(data, {2266    status: import_smithy_client.expectString2267  });2268  Object.assign(contents, doc);2269  return contents;2270}, "de_CancelMLModelTrainingJobCommand");2271var de_CancelMLModelTransformJobCommand = /* @__PURE__ */ __name(async (output, context) => {2272  if (output.statusCode !== 200 && output.statusCode >= 300) {2273    return de_CommandError(output, context);2274  }2275  const contents = (0, import_smithy_client.map)({2276    $metadata: deserializeMetadata(output)2277  });2278  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2279  const doc = (0, import_smithy_client.take)(data, {2280    status: import_smithy_client.expectString2281  });2282  Object.assign(contents, doc);2283  return contents;2284}, "de_CancelMLModelTransformJobCommand");2285var de_CancelOpenCypherQueryCommand = /* @__PURE__ */ __name(async (output, context) => {2286  if (output.statusCode !== 200 && output.statusCode >= 300) {2287    return de_CommandError(output, context);2288  }2289  const contents = (0, import_smithy_client.map)({2290    $metadata: deserializeMetadata(output)2291  });2292  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2293  const doc = (0, import_smithy_client.take)(data, {2294    payload: import_smithy_client.expectBoolean,2295    status: import_smithy_client.expectString2296  });2297  Object.assign(contents, doc);2298  return contents;2299}, "de_CancelOpenCypherQueryCommand");2300var de_CreateMLEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {2301  if (output.statusCode !== 200 && output.statusCode >= 300) {2302    return de_CommandError(output, context);2303  }2304  const contents = (0, import_smithy_client.map)({2305    $metadata: deserializeMetadata(output)2306  });2307  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2308  const doc = (0, import_smithy_client.take)(data, {2309    arn: import_smithy_client.expectString,2310    creationTimeInMillis: import_smithy_client.expectLong,2311    id: import_smithy_client.expectString2312  });2313  Object.assign(contents, doc);2314  return contents;2315}, "de_CreateMLEndpointCommand");2316var de_DeleteMLEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {2317  if (output.statusCode !== 200 && output.statusCode >= 300) {2318    return de_CommandError(output, context);2319  }2320  const contents = (0, import_smithy_client.map)({2321    $metadata: deserializeMetadata(output)2322  });2323  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2324  const doc = (0, import_smithy_client.take)(data, {2325    status: import_smithy_client.expectString2326  });2327  Object.assign(contents, doc);2328  return contents;2329}, "de_DeleteMLEndpointCommand");2330var de_DeletePropertygraphStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {2331  if (output.statusCode !== 200 && output.statusCode >= 300) {2332    return de_CommandError(output, context);2333  }2334  const contents = (0, import_smithy_client.map)({2335    $metadata: deserializeMetadata(output)2336  });2337  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2338  const doc = (0, import_smithy_client.take)(data, {2339    payload: import_smithy_client._json,2340    status: import_smithy_client.expectString2341  });2342  Object.assign(contents, doc);2343  (0, import_smithy_client.map)(contents, {2344    statusCode: [, output.statusCode]2345  });2346  return contents;2347}, "de_DeletePropertygraphStatisticsCommand");2348var de_DeleteSparqlStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {2349  if (output.statusCode !== 200 && output.statusCode >= 300) {2350    return de_CommandError(output, context);2351  }2352  const contents = (0, import_smithy_client.map)({2353    $metadata: deserializeMetadata(output)2354  });2355  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2356  const doc = (0, import_smithy_client.take)(data, {2357    payload: import_smithy_client._json,2358    status: import_smithy_client.expectString2359  });2360  Object.assign(contents, doc);2361  (0, import_smithy_client.map)(contents, {2362    statusCode: [, output.statusCode]2363  });2364  return contents;2365}, "de_DeleteSparqlStatisticsCommand");2366var de_ExecuteFastResetCommand = /* @__PURE__ */ __name(async (output, context) => {2367  if (output.statusCode !== 200 && output.statusCode >= 300) {2368    return de_CommandError(output, context);2369  }2370  const contents = (0, import_smithy_client.map)({2371    $metadata: deserializeMetadata(output)2372  });2373  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2374  const doc = (0, import_smithy_client.take)(data, {2375    payload: import_smithy_client._json,2376    status: import_smithy_client.expectString2377  });2378  Object.assign(contents, doc);2379  return contents;2380}, "de_ExecuteFastResetCommand");2381var de_ExecuteGremlinExplainQueryCommand = /* @__PURE__ */ __name(async (output, context) => {2382  if (output.statusCode !== 200 && output.statusCode >= 300) {2383    return de_CommandError(output, context);2384  }2385  const contents = (0, import_smithy_client.map)({2386    $metadata: deserializeMetadata(output)2387  });2388  const data = await (0, import_smithy_client.collectBody)(output.body, context);2389  contents.output = data;2390  return contents;2391}, "de_ExecuteGremlinExplainQueryCommand");2392var de_ExecuteGremlinProfileQueryCommand = /* @__PURE__ */ __name(async (output, context) => {2393  if (output.statusCode !== 200 && output.statusCode >= 300) {2394    return de_CommandError(output, context);2395  }2396  const contents = (0, import_smithy_client.map)({2397    $metadata: deserializeMetadata(output)2398  });2399  const data = await (0, import_smithy_client.collectBody)(output.body, context);2400  contents.output = data;2401  return contents;2402}, "de_ExecuteGremlinProfileQueryCommand");2403var de_ExecuteGremlinQueryCommand = /* @__PURE__ */ __name(async (output, context) => {2404  if (output.statusCode !== 200 && output.statusCode >= 300) {2405    return de_CommandError(output, context);2406  }2407  const contents = (0, import_smithy_client.map)({2408    $metadata: deserializeMetadata(output)2409  });2410  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2411  const doc = (0, import_smithy_client.take)(data, {2412    meta: /* @__PURE__ */ __name((_) => de_Document(_, context), "meta"),2413    requestId: import_smithy_client.expectString,2414    result: /* @__PURE__ */ __name((_) => de_Document(_, context), "result"),2415    status: /* @__PURE__ */ __name((_) => de_GremlinQueryStatusAttributes(_, context), "status")2416  });2417  Object.assign(contents, doc);2418  return contents;2419}, "de_ExecuteGremlinQueryCommand");2420var de_ExecuteOpenCypherExplainQueryCommand = /* @__PURE__ */ __name(async (output, context) => {2421  if (output.statusCode !== 200 && output.statusCode >= 300) {2422    return de_CommandError(output, context);2423  }2424  const contents = (0, import_smithy_client.map)({2425    $metadata: deserializeMetadata(output)2426  });2427  const data = await (0, import_smithy_client.collectBody)(output.body, context);2428  contents.results = data;2429  return contents;2430}, "de_ExecuteOpenCypherExplainQueryCommand");2431var de_ExecuteOpenCypherQueryCommand = /* @__PURE__ */ __name(async (output, context) => {2432  if (output.statusCode !== 200 && output.statusCode >= 300) {2433    return de_CommandError(output, context);2434  }2435  const contents = (0, import_smithy_client.map)({2436    $metadata: deserializeMetadata(output)2437  });2438  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2439  const doc = (0, import_smithy_client.take)(data, {2440    results: /* @__PURE__ */ __name((_) => de_Document(_, context), "results")2441  });2442  Object.assign(contents, doc);2443  return contents;2444}, "de_ExecuteOpenCypherQueryCommand");2445var de_GetEngineStatusCommand = /* @__PURE__ */ __name(async (output, context) => {2446  if (output.statusCode !== 200 && output.statusCode >= 300) {2447    return de_CommandError(output, context);2448  }2449  const contents = (0, import_smithy_client.map)({2450    $metadata: deserializeMetadata(output)2451  });2452  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2453  const doc = (0, import_smithy_client.take)(data, {2454    dbEngineVersion: import_smithy_client.expectString,2455    dfeQueryEngine: import_smithy_client.expectString,2456    features: /* @__PURE__ */ __name((_) => de_DocumentValuedMap(_, context), "features"),2457    gremlin: import_smithy_client._json,2458    labMode: import_smithy_client._json,2459    opencypher: import_smithy_client._json,2460    role: import_smithy_client.expectString,2461    rollingBackTrxCount: import_smithy_client.expectInt32,2462    rollingBackTrxEarliestStartTime: import_smithy_client.expectString,2463    settings: import_smithy_client._json,2464    sparql: import_smithy_client._json,2465    startTime: import_smithy_client.expectString,2466    status: import_smithy_client.expectString2467  });2468  Object.assign(contents, doc);2469  return contents;2470}, "de_GetEngineStatusCommand");2471var de_GetGremlinQueryStatusCommand = /* @__PURE__ */ __name(async (output, context) => {2472  if (output.statusCode !== 200 && output.statusCode >= 300) {2473    return de_CommandError(output, context);2474  }2475  const contents = (0, import_smithy_client.map)({2476    $metadata: deserializeMetadata(output)2477  });2478  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2479  const doc = (0, import_smithy_client.take)(data, {2480    queryEvalStats: /* @__PURE__ */ __name((_) => de_QueryEvalStats(_, context), "queryEvalStats"),2481    queryId: import_smithy_client.expectString,2482    queryString: import_smithy_client.expectString2483  });2484  Object.assign(contents, doc);2485  return contents;2486}, "de_GetGremlinQueryStatusCommand");2487var de_GetLoaderJobStatusCommand = /* @__PURE__ */ __name(async (output, context) => {2488  if (output.statusCode !== 200 && output.statusCode >= 300) {2489    return de_CommandError(output, context);2490  }2491  const contents = (0, import_smithy_client.map)({2492    $metadata: deserializeMetadata(output)2493  });2494  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2495  const doc = (0, import_smithy_client.take)(data, {2496    payload: /* @__PURE__ */ __name((_) => de_Document(_, context), "payload"),2497    status: import_smithy_client.expectString2498  });2499  Object.assign(contents, doc);2500  return contents;2501}, "de_GetLoaderJobStatusCommand");2502var de_GetMLDataProcessingJobCommand = /* @__PURE__ */ __name(async (output, context) => {2503  if (output.statusCode !== 200 && output.statusCode >= 300) {2504    return de_CommandError(output, context);2505  }2506  const contents = (0, import_smithy_client.map)({2507    $metadata: deserializeMetadata(output)2508  });2509  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2510  const doc = (0, import_smithy_client.take)(data, {2511    id: import_smithy_client.expectString,2512    processingJob: import_smithy_client._json,2513    status: import_smithy_client.expectString2514  });2515  Object.assign(contents, doc);2516  return contents;2517}, "de_GetMLDataProcessingJobCommand");2518var de_GetMLEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {2519  if (output.statusCode !== 200 && output.statusCode >= 300) {2520    return de_CommandError(output, context);2521  }2522  const contents = (0, import_smithy_client.map)({2523    $metadata: deserializeMetadata(output)2524  });2525  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2526  const doc = (0, import_smithy_client.take)(data, {2527    endpoint: import_smithy_client._json,2528    endpointConfig: import_smithy_client._json,2529    id: import_smithy_client.expectString,2530    status: import_smithy_client.expectString2531  });2532  Object.assign(contents, doc);2533  return contents;2534}, "de_GetMLEndpointCommand");2535var de_GetMLModelTrainingJobCommand = /* @__PURE__ */ __name(async (output, context) => {2536  if (output.statusCode !== 200 && output.statusCode >= 300) {2537    return de_CommandError(output, context);2538  }2539  const contents = (0, import_smithy_client.map)({2540    $metadata: deserializeMetadata(output)2541  });2542  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2543  const doc = (0, import_smithy_client.take)(data, {2544    hpoJob: import_smithy_client._json,2545    id: import_smithy_client.expectString,2546    mlModels: import_smithy_client._json,2547    modelTransformJob: import_smithy_client._json,2548    processingJob: import_smithy_client._json,2549    status: import_smithy_client.expectString2550  });2551  Object.assign(contents, doc);2552  return contents;2553}, "de_GetMLModelTrainingJobCommand");2554var de_GetMLModelTransformJobCommand = /* @__PURE__ */ __name(async (output, context) => {2555  if (output.statusCode !== 200 && output.statusCode >= 300) {2556    return de_CommandError(output, context);2557  }2558  const contents = (0, import_smithy_client.map)({2559    $metadata: deserializeMetadata(output)2560  });2561  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2562  const doc = (0, import_smithy_client.take)(data, {2563    baseProcessingJob: import_smithy_client._json,2564    id: import_smithy_client.expectString,2565    models: import_smithy_client._json,2566    remoteModelTransformJob: import_smithy_client._json,2567    status: import_smithy_client.expectString2568  });2569  Object.assign(contents, doc);2570  return contents;2571}, "de_GetMLModelTransformJobCommand");2572var de_GetOpenCypherQueryStatusCommand = /* @__PURE__ */ __name(async (output, context) => {2573  if (output.statusCode !== 200 && output.statusCode >= 300) {2574    return de_CommandError(output, context);2575  }2576  const contents = (0, import_smithy_client.map)({2577    $metadata: deserializeMetadata(output)2578  });2579  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2580  const doc = (0, import_smithy_client.take)(data, {2581    queryEvalStats: /* @__PURE__ */ __name((_) => de_QueryEvalStats(_, context), "queryEvalStats"),2582    queryId: import_smithy_client.expectString,2583    queryString: import_smithy_client.expectString2584  });2585  Object.assign(contents, doc);2586  return contents;2587}, "de_GetOpenCypherQueryStatusCommand");2588var de_GetPropertygraphStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {2589  if (output.statusCode !== 200 && output.statusCode >= 300) {2590    return de_CommandError(output, context);2591  }2592  const contents = (0, import_smithy_client.map)({2593    $metadata: deserializeMetadata(output)2594  });2595  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2596  const doc = (0, import_smithy_client.take)(data, {2597    payload: /* @__PURE__ */ __name((_) => de_Statistics(_, context), "payload"),2598    status: import_smithy_client.expectString2599  });2600  Object.assign(contents, doc);2601  return contents;2602}, "de_GetPropertygraphStatisticsCommand");2603var de_GetPropertygraphStreamCommand = /* @__PURE__ */ __name(async (output, context) => {2604  if (output.statusCode !== 200 && output.statusCode >= 300) {2605    return de_CommandError(output, context);2606  }2607  const contents = (0, import_smithy_client.map)({2608    $metadata: deserializeMetadata(output)2609  });2610  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2611  const doc = (0, import_smithy_client.take)(data, {2612    format: import_smithy_client.expectString,2613    lastEventId: import_smithy_client._json,2614    lastTrxTimestampInMillis: [, import_smithy_client.expectLong, `lastTrxTimestamp`],2615    records: /* @__PURE__ */ __name((_) => de_PropertygraphRecordsList(_, context), "records"),2616    totalRecords: import_smithy_client.expectInt322617  });2618  Object.assign(contents, doc);2619  return contents;2620}, "de_GetPropertygraphStreamCommand");2621var de_GetPropertygraphSummaryCommand = /* @__PURE__ */ __name(async (output, context) => {2622  if (output.statusCode !== 200 && output.statusCode >= 300) {2623    return de_CommandError(output, context);2624  }2625  const contents = (0, import_smithy_client.map)({2626    $metadata: deserializeMetadata(output)2627  });2628  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2629  const doc = (0, import_smithy_client.take)(data, {2630    payload: /* @__PURE__ */ __name((_) => de_PropertygraphSummaryValueMap(_, context), "payload")2631  });2632  Object.assign(contents, doc);2633  (0, import_smithy_client.map)(contents, {2634    statusCode: [, output.statusCode]2635  });2636  return contents;2637}, "de_GetPropertygraphSummaryCommand");2638var de_GetRDFGraphSummaryCommand = /* @__PURE__ */ __name(async (output, context) => {2639  if (output.statusCode !== 200 && output.statusCode >= 300) {2640    return de_CommandError(output, context);2641  }2642  const contents = (0, import_smithy_client.map)({2643    $metadata: deserializeMetadata(output)2644  });2645  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2646  const doc = (0, import_smithy_client.take)(data, {2647    payload: /* @__PURE__ */ __name((_) => de_RDFGraphSummaryValueMap(_, context), "payload")2648  });2649  Object.assign(contents, doc);2650  (0, import_smithy_client.map)(contents, {2651    statusCode: [, output.statusCode]2652  });2653  return contents;2654}, "de_GetRDFGraphSummaryCommand");2655var de_GetSparqlStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {2656  if (output.statusCode !== 200 && output.statusCode >= 300) {2657    return de_CommandError(output, context);2658  }2659  const contents = (0, import_smithy_client.map)({2660    $metadata: deserializeMetadata(output)2661  });2662  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2663  const doc = (0, import_smithy_client.take)(data, {2664    payload: /* @__PURE__ */ __name((_) => de_Statistics(_, context), "payload"),2665    status: import_smithy_client.expectString2666  });2667  Object.assign(contents, doc);2668  return contents;2669}, "de_GetSparqlStatisticsCommand");2670var de_GetSparqlStreamCommand = /* @__PURE__ */ __name(async (output, context) => {2671  if (output.statusCode !== 200 && output.statusCode >= 300) {2672    return de_CommandError(output, context);2673  }2674  const contents = (0, import_smithy_client.map)({2675    $metadata: deserializeMetadata(output)2676  });2677  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2678  const doc = (0, import_smithy_client.take)(data, {2679    format: import_smithy_client.expectString,2680    lastEventId: import_smithy_client._json,2681    lastTrxTimestampInMillis: [, import_smithy_client.expectLong, `lastTrxTimestamp`],2682    records: /* @__PURE__ */ __name((_) => de_SparqlRecordsList(_, context), "records"),2683    totalRecords: import_smithy_client.expectInt322684  });2685  Object.assign(contents, doc);2686  return contents;2687}, "de_GetSparqlStreamCommand");2688var de_ListGremlinQueriesCommand = /* @__PURE__ */ __name(async (output, context) => {2689  if (output.statusCode !== 200 && output.statusCode >= 300) {2690    return de_CommandError(output, context);2691  }2692  const contents = (0, import_smithy_client.map)({2693    $metadata: deserializeMetadata(output)2694  });2695  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2696  const doc = (0, import_smithy_client.take)(data, {2697    acceptedQueryCount: import_smithy_client.expectInt32,2698    queries: /* @__PURE__ */ __name((_) => de_GremlinQueries(_, context), "queries"),2699    runningQueryCount: import_smithy_client.expectInt322700  });2701  Object.assign(contents, doc);2702  return contents;2703}, "de_ListGremlinQueriesCommand");2704var de_ListLoaderJobsCommand = /* @__PURE__ */ __name(async (output, context) => {2705  if (output.statusCode !== 200 && output.statusCode >= 300) {2706    return de_CommandError(output, context);2707  }2708  const contents = (0, import_smithy_client.map)({2709    $metadata: deserializeMetadata(output)2710  });2711  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2712  const doc = (0, import_smithy_client.take)(data, {2713    payload: import_smithy_client._json,2714    status: import_smithy_client.expectString2715  });2716  Object.assign(contents, doc);2717  return contents;2718}, "de_ListLoaderJobsCommand");2719var de_ListMLDataProcessingJobsCommand = /* @__PURE__ */ __name(async (output, context) => {2720  if (output.statusCode !== 200 && output.statusCode >= 300) {2721    return de_CommandError(output, context);2722  }2723  const contents = (0, import_smithy_client.map)({2724    $metadata: deserializeMetadata(output)2725  });2726  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2727  const doc = (0, import_smithy_client.take)(data, {2728    ids: import_smithy_client._json2729  });2730  Object.assign(contents, doc);2731  return contents;2732}, "de_ListMLDataProcessingJobsCommand");2733var de_ListMLEndpointsCommand = /* @__PURE__ */ __name(async (output, context) => {2734  if (output.statusCode !== 200 && output.statusCode >= 300) {2735    return de_CommandError(output, context);2736  }2737  const contents = (0, import_smithy_client.map)({2738    $metadata: deserializeMetadata(output)2739  });2740  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2741  const doc = (0, import_smithy_client.take)(data, {2742    ids: import_smithy_client._json2743  });2744  Object.assign(contents, doc);2745  return contents;2746}, "de_ListMLEndpointsCommand");2747var de_ListMLModelTrainingJobsCommand = /* @__PURE__ */ __name(async (output, context) => {2748  if (output.statusCode !== 200 && output.statusCode >= 300) {2749    return de_CommandError(output, context);2750  }2751  const contents = (0, import_smithy_client.map)({2752    $metadata: deserializeMetadata(output)2753  });2754  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2755  const doc = (0, import_smithy_client.take)(data, {2756    ids: import_smithy_client._json2757  });2758  Object.assign(contents, doc);2759  return contents;2760}, "de_ListMLModelTrainingJobsCommand");2761var de_ListMLModelTransformJobsCommand = /* @__PURE__ */ __name(async (output, context) => {2762  if (output.statusCode !== 200 && output.statusCode >= 300) {2763    return de_CommandError(output, context);2764  }2765  const contents = (0, import_smithy_client.map)({2766    $metadata: deserializeMetadata(output)2767  });2768  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2769  const doc = (0, import_smithy_client.take)(data, {2770    ids: import_smithy_client._json2771  });2772  Object.assign(contents, doc);2773  return contents;2774}, "de_ListMLModelTransformJobsCommand");2775var de_ListOpenCypherQueriesCommand = /* @__PURE__ */ __name(async (output, context) => {2776  if (output.statusCode !== 200 && output.statusCode >= 300) {2777    return de_CommandError(output, context);2778  }2779  const contents = (0, import_smithy_client.map)({2780    $metadata: deserializeMetadata(output)2781  });2782  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2783  const doc = (0, import_smithy_client.take)(data, {2784    acceptedQueryCount: import_smithy_client.expectInt32,2785    queries: /* @__PURE__ */ __name((_) => de_OpenCypherQueries(_, context), "queries"),2786    runningQueryCount: import_smithy_client.expectInt322787  });2788  Object.assign(contents, doc);2789  return contents;2790}, "de_ListOpenCypherQueriesCommand");2791var de_ManagePropertygraphStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {2792  if (output.statusCode !== 200 && output.statusCode >= 300) {2793    return de_CommandError(output, context);2794  }2795  const contents = (0, import_smithy_client.map)({2796    $metadata: deserializeMetadata(output)2797  });2798  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2799  const doc = (0, import_smithy_client.take)(data, {2800    payload: import_smithy_client._json,2801    status: import_smithy_client.expectString2802  });2803  Object.assign(contents, doc);2804  return contents;2805}, "de_ManagePropertygraphStatisticsCommand");2806var de_ManageSparqlStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {2807  if (output.statusCode !== 200 && output.statusCode >= 300) {2808    return de_CommandError(output, context);2809  }2810  const contents = (0, import_smithy_client.map)({2811    $metadata: deserializeMetadata(output)2812  });2813  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2814  const doc = (0, import_smithy_client.take)(data, {2815    payload: import_smithy_client._json,2816    status: import_smithy_client.expectString2817  });2818  Object.assign(contents, doc);2819  return contents;2820}, "de_ManageSparqlStatisticsCommand");2821var de_StartLoaderJobCommand = /* @__PURE__ */ __name(async (output, context) => {2822  if (output.statusCode !== 200 && output.statusCode >= 300) {2823    return de_CommandError(output, context);2824  }2825  const contents = (0, import_smithy_client.map)({2826    $metadata: deserializeMetadata(output)2827  });2828  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2829  const doc = (0, import_smithy_client.take)(data, {2830    payload: import_smithy_client._json,2831    status: import_smithy_client.expectString2832  });2833  Object.assign(contents, doc);2834  return contents;2835}, "de_StartLoaderJobCommand");2836var de_StartMLDataProcessingJobCommand = /* @__PURE__ */ __name(async (output, context) => {2837  if (output.statusCode !== 200 && output.statusCode >= 300) {2838    return de_CommandError(output, context);2839  }2840  const contents = (0, import_smithy_client.map)({2841    $metadata: deserializeMetadata(output)2842  });2843  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2844  const doc = (0, import_smithy_client.take)(data, {2845    arn: import_smithy_client.expectString,2846    creationTimeInMillis: import_smithy_client.expectLong,2847    id: import_smithy_client.expectString2848  });2849  Object.assign(contents, doc);2850  return contents;2851}, "de_StartMLDataProcessingJobCommand");2852var de_StartMLModelTrainingJobCommand = /* @__PURE__ */ __name(async (output, context) => {2853  if (output.statusCode !== 200 && output.statusCode >= 300) {2854    return de_CommandError(output, context);2855  }2856  const contents = (0, import_smithy_client.map)({2857    $metadata: deserializeMetadata(output)2858  });2859  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2860  const doc = (0, import_smithy_client.take)(data, {2861    arn: import_smithy_client.expectString,2862    creationTimeInMillis: import_smithy_client.expectLong,2863    id: import_smithy_client.expectString2864  });2865  Object.assign(contents, doc);2866  return contents;2867}, "de_StartMLModelTrainingJobCommand");2868var de_StartMLModelTransformJobCommand = /* @__PURE__ */ __name(async (output, context) => {2869  if (output.statusCode !== 200 && output.statusCode >= 300) {2870    return de_CommandError(output, context);2871  }2872  const contents = (0, import_smithy_client.map)({2873    $metadata: deserializeMetadata(output)2874  });2875  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");2876  const doc = (0, import_smithy_client.take)(data, {2877    arn: import_smithy_client.expectString,2878    creationTimeInMillis: import_smithy_client.expectLong,2879    id: import_smithy_client.expectString2880  });2881  Object.assign(contents, doc);2882  return contents;2883}, "de_StartMLModelTransformJobCommand");2884var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {2885  const parsedOutput = {2886    ...output,2887    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)2888  };2889  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);2890  switch (errorCode) {2891    case "BadRequestException":2892    case "com.amazonaws.neptunedata#BadRequestException":2893      throw await de_BadRequestExceptionRes(parsedOutput, context);2894    case "ClientTimeoutException":2895    case "com.amazonaws.neptunedata#ClientTimeoutException":2896      throw await de_ClientTimeoutExceptionRes(parsedOutput, context);2897    case "ConcurrentModificationException":2898    case "com.amazonaws.neptunedata#ConcurrentModificationException":2899      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);2900    case "ConstraintViolationException":2901    case "com.amazonaws.neptunedata#ConstraintViolationException":2902      throw await de_ConstraintViolationExceptionRes(parsedOutput, context);2903    case "FailureByQueryException":2904    case "com.amazonaws.neptunedata#FailureByQueryException":2905      throw await de_FailureByQueryExceptionRes(parsedOutput, context);2906    case "IllegalArgumentException":2907    case "com.amazonaws.neptunedata#IllegalArgumentException":2908      throw await de_IllegalArgumentExceptionRes(parsedOutput, context);2909    case "InvalidArgumentException":2910    case "com.amazonaws.neptunedata#InvalidArgumentException":2911      throw await de_InvalidArgumentExceptionRes(parsedOutput, context);2912    case "InvalidParameterException":2913    case "com.amazonaws.neptunedata#InvalidParameterException":2914      throw await de_InvalidParameterExceptionRes(parsedOutput, context);2915    case "MissingParameterException":2916    case "com.amazonaws.neptunedata#MissingParameterException":2917      throw await de_MissingParameterExceptionRes(parsedOutput, context);2918    case "ParsingException":2919    case "com.amazonaws.neptunedata#ParsingException":2920      throw await de_ParsingExceptionRes(parsedOutput, context);2921    case "PreconditionsFailedException":2922    case "com.amazonaws.neptunedata#PreconditionsFailedException":2923      throw await de_PreconditionsFailedExceptionRes(parsedOutput, context);2924    case "TimeLimitExceededException":2925    case "com.amazonaws.neptunedata#TimeLimitExceededException":2926      throw await de_TimeLimitExceededExceptionRes(parsedOutput, context);2927    case "TooManyRequestsException":2928    case "com.amazonaws.neptunedata#TooManyRequestsException":2929      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);2930    case "UnsupportedOperationException":2931    case "com.amazonaws.neptunedata#UnsupportedOperationException":2932      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);2933    case "BulkLoadIdNotFoundException":2934    case "com.amazonaws.neptunedata#BulkLoadIdNotFoundException":2935      throw await de_BulkLoadIdNotFoundExceptionRes(parsedOutput, context);2936    case "InternalFailureException":2937    case "com.amazonaws.neptunedata#InternalFailureException":2938      throw await de_InternalFailureExceptionRes(parsedOutput, context);2939    case "LoadUrlAccessDeniedException":2940    case "com.amazonaws.neptunedata#LoadUrlAccessDeniedException":2941      throw await de_LoadUrlAccessDeniedExceptionRes(parsedOutput, context);2942    case "MLResourceNotFoundException":2943    case "com.amazonaws.neptunedata#MLResourceNotFoundException":2944      throw await de_MLResourceNotFoundExceptionRes(parsedOutput, context);2945    case "InvalidNumericDataException":2946    case "com.amazonaws.neptunedata#InvalidNumericDataException":2947      throw await de_InvalidNumericDataExceptionRes(parsedOutput, context);2948    case "AccessDeniedException":2949    case "com.amazonaws.neptunedata#AccessDeniedException":2950      throw await de_AccessDeniedExceptionRes(parsedOutput, context);2951    case "ReadOnlyViolationException":2952    case "com.amazonaws.neptunedata#ReadOnlyViolationException":2953      throw await de_ReadOnlyViolationExceptionRes(parsedOutput, context);2954    case "StatisticsNotAvailableException":2955    case "com.amazonaws.neptunedata#StatisticsNotAvailableException":2956      throw await de_StatisticsNotAvailableExceptionRes(parsedOutput, context);2957    case "MethodNotAllowedException":2958    case "com.amazonaws.neptunedata#MethodNotAllowedException":2959      throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);2960    case "ServerShutdownException":2961    case "com.amazonaws.neptunedata#ServerShutdownException":2962      throw await de_ServerShutdownExceptionRes(parsedOutput, context);2963    case "CancelledByUserException":2964    case "com.amazonaws.neptunedata#CancelledByUserException":2965      throw await de_CancelledByUserExceptionRes(parsedOutput, context);2966    case "MalformedQueryException":2967    case "com.amazonaws.neptunedata#MalformedQueryException":2968      throw await de_MalformedQueryExceptionRes(parsedOutput, context);2969    case "MemoryLimitExceededException":2970    case "com.amazonaws.neptunedata#MemoryLimitExceededException":2971      throw await de_MemoryLimitExceededExceptionRes(parsedOutput, context);2972    case "QueryLimitExceededException":2973    case "com.amazonaws.neptunedata#QueryLimitExceededException":2974      throw await de_QueryLimitExceededExceptionRes(parsedOutput, context);2975    case "QueryLimitException":2976    case "com.amazonaws.neptunedata#QueryLimitException":2977      throw await de_QueryLimitExceptionRes(parsedOutput, context);2978    case "QueryTooLargeException":2979    case "com.amazonaws.neptunedata#QueryTooLargeException":2980      throw await de_QueryTooLargeExceptionRes(parsedOutput, context);2981    case "ExpiredStreamException":2982    case "com.amazonaws.neptunedata#ExpiredStreamException":2983      throw await de_ExpiredStreamExceptionRes(parsedOutput, context);2984    case "StreamRecordsNotFoundException":2985    case "com.amazonaws.neptunedata#StreamRecordsNotFoundException":2986      throw await de_StreamRecordsNotFoundExceptionRes(parsedOutput, context);2987    case "ThrottlingException":2988    case "com.amazonaws.neptunedata#ThrottlingException":2989      throw await de_ThrottlingExceptionRes(parsedOutput, context);2990    case "S3Exception":2991    case "com.amazonaws.neptunedata#S3Exception":2992      throw await de_S3ExceptionRes(parsedOutput, context);2993    default:2994      const parsedBody = parsedOutput.body;2995      return throwDefaultError({2996        output,2997        parsedBody,2998        errorCode2999      });3000  }3001}, "de_CommandError");3002var throwDefaultError = (0, import_smithy_client.withBaseException)(NeptunedataServiceException);3003var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3004  const contents = (0, import_smithy_client.map)({});3005  const data = parsedOutput.body;3006  const doc = (0, import_smithy_client.take)(data, {3007    code: import_smithy_client.expectString,3008    detailedMessage: import_smithy_client.expectString,3009    requestId: import_smithy_client.expectString3010  });3011  Object.assign(contents, doc);3012  const exception = new AccessDeniedException({3013    $metadata: deserializeMetadata(parsedOutput),3014    ...contents3015  });3016  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3017}, "de_AccessDeniedExceptionRes");3018var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3019  const contents = (0, import_smithy_client.map)({});3020  const data = parsedOutput.body;3021  const doc = (0, import_smithy_client.take)(data, {3022    code: import_smithy_client.expectString,3023    detailedMessage: import_smithy_client.expectString,3024    requestId: import_smithy_client.expectString3025  });3026  Object.assign(contents, doc);3027  const exception = new BadRequestException({3028    $metadata: deserializeMetadata(parsedOutput),3029    ...contents3030  });3031  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3032}, "de_BadRequestExceptionRes");3033var de_BulkLoadIdNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3034  const contents = (0, import_smithy_client.map)({});3035  const data = parsedOutput.body;3036  const doc = (0, import_smithy_client.take)(data, {3037    code: import_smithy_client.expectString,3038    detailedMessage: import_smithy_client.expectString,3039    requestId: import_smithy_client.expectString3040  });3041  Object.assign(contents, doc);3042  const exception = new BulkLoadIdNotFoundException({3043    $metadata: deserializeMetadata(parsedOutput),3044    ...contents3045  });3046  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3047}, "de_BulkLoadIdNotFoundExceptionRes");3048var de_CancelledByUserExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3049  const contents = (0, import_smithy_client.map)({});3050  const data = parsedOutput.body;3051  const doc = (0, import_smithy_client.take)(data, {3052    code: import_smithy_client.expectString,3053    detailedMessage: import_smithy_client.expectString,3054    requestId: import_smithy_client.expectString3055  });3056  Object.assign(contents, doc);3057  const exception = new CancelledByUserException({3058    $metadata: deserializeMetadata(parsedOutput),3059    ...contents3060  });3061  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3062}, "de_CancelledByUserExceptionRes");3063var de_ClientTimeoutExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3064  const contents = (0, import_smithy_client.map)({});3065  const data = parsedOutput.body;3066  const doc = (0, import_smithy_client.take)(data, {3067    code: import_smithy_client.expectString,3068    detailedMessage: import_smithy_client.expectString,3069    requestId: import_smithy_client.expectString3070  });3071  Object.assign(contents, doc);3072  const exception = new ClientTimeoutException({3073    $metadata: deserializeMetadata(parsedOutput),3074    ...contents3075  });3076  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3077}, "de_ClientTimeoutExceptionRes");3078var de_ConcurrentModificationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3079  const contents = (0, import_smithy_client.map)({});3080  const data = parsedOutput.body;3081  const doc = (0, import_smithy_client.take)(data, {3082    code: import_smithy_client.expectString,3083    detailedMessage: import_smithy_client.expectString,3084    requestId: import_smithy_client.expectString3085  });3086  Object.assign(contents, doc);3087  const exception = new ConcurrentModificationException({3088    $metadata: deserializeMetadata(parsedOutput),3089    ...contents3090  });3091  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3092}, "de_ConcurrentModificationExceptionRes");3093var de_ConstraintViolationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3094  const contents = (0, import_smithy_client.map)({});3095  const data = parsedOutput.body;3096  const doc = (0, import_smithy_client.take)(data, {3097    code: import_smithy_client.expectString,3098    detailedMessage: import_smithy_client.expectString,3099    requestId: import_smithy_client.expectString3100  });3101  Object.assign(contents, doc);3102  const exception = new ConstraintViolationException({3103    $metadata: deserializeMetadata(parsedOutput),3104    ...contents3105  });3106  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3107}, "de_ConstraintViolationExceptionRes");3108var de_ExpiredStreamExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3109  const contents = (0, import_smithy_client.map)({});3110  const data = parsedOutput.body;3111  const doc = (0, import_smithy_client.take)(data, {3112    code: import_smithy_client.expectString,3113    detailedMessage: import_smithy_client.expectString,3114    requestId: import_smithy_client.expectString3115  });3116  Object.assign(contents, doc);3117  const exception = new ExpiredStreamException({3118    $metadata: deserializeMetadata(parsedOutput),3119    ...contents3120  });3121  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3122}, "de_ExpiredStreamExceptionRes");3123var de_FailureByQueryExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3124  const contents = (0, import_smithy_client.map)({});3125  const data = parsedOutput.body;3126  const doc = (0, import_smithy_client.take)(data, {3127    code: import_smithy_client.expectString,3128    detailedMessage: import_smithy_client.expectString,3129    requestId: import_smithy_client.expectString3130  });3131  Object.assign(contents, doc);3132  const exception = new FailureByQueryException({3133    $metadata: deserializeMetadata(parsedOutput),3134    ...contents3135  });3136  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3137}, "de_FailureByQueryExceptionRes");3138var de_IllegalArgumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3139  const contents = (0, import_smithy_client.map)({});3140  const data = parsedOutput.body;3141  const doc = (0, import_smithy_client.take)(data, {3142    code: import_smithy_client.expectString,3143    detailedMessage: import_smithy_client.expectString,3144    requestId: import_smithy_client.expectString3145  });3146  Object.assign(contents, doc);3147  const exception = new IllegalArgumentException({3148    $metadata: deserializeMetadata(parsedOutput),3149    ...contents3150  });3151  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3152}, "de_IllegalArgumentExceptionRes");3153var de_InternalFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3154  const contents = (0, import_smithy_client.map)({});3155  const data = parsedOutput.body;3156  const doc = (0, import_smithy_client.take)(data, {3157    code: import_smithy_client.expectString,3158    detailedMessage: import_smithy_client.expectString,3159    requestId: import_smithy_client.expectString3160  });3161  Object.assign(contents, doc);3162  const exception = new InternalFailureException({3163    $metadata: deserializeMetadata(parsedOutput),3164    ...contents3165  });3166  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3167}, "de_InternalFailureExceptionRes");3168var de_InvalidArgumentExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3169  const contents = (0, import_smithy_client.map)({});3170  const data = parsedOutput.body;3171  const doc = (0, import_smithy_client.take)(data, {3172    code: import_smithy_client.expectString,3173    detailedMessage: import_smithy_client.expectString,3174    requestId: import_smithy_client.expectString3175  });3176  Object.assign(contents, doc);3177  const exception = new InvalidArgumentException({3178    $metadata: deserializeMetadata(parsedOutput),3179    ...contents3180  });3181  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3182}, "de_InvalidArgumentExceptionRes");3183var de_InvalidNumericDataExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3184  const contents = (0, import_smithy_client.map)({});3185  const data = parsedOutput.body;3186  const doc = (0, import_smithy_client.take)(data, {3187    code: import_smithy_client.expectString,3188    detailedMessage: import_smithy_client.expectString,3189    requestId: import_smithy_client.expectString3190  });3191  Object.assign(contents, doc);3192  const exception = new InvalidNumericDataException({3193    $metadata: deserializeMetadata(parsedOutput),3194    ...contents3195  });3196  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3197}, "de_InvalidNumericDataExceptionRes");3198var de_InvalidParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3199  const contents = (0, import_smithy_client.map)({});3200  const data = parsedOutput.body;3201  const doc = (0, import_smithy_client.take)(data, {3202    code: import_smithy_client.expectString,3203    detailedMessage: import_smithy_client.expectString,3204    requestId: import_smithy_client.expectString3205  });3206  Object.assign(contents, doc);3207  const exception = new InvalidParameterException({3208    $metadata: deserializeMetadata(parsedOutput),3209    ...contents3210  });3211  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3212}, "de_InvalidParameterExceptionRes");3213var de_LoadUrlAccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3214  const contents = (0, import_smithy_client.map)({});3215  const data = parsedOutput.body;3216  const doc = (0, import_smithy_client.take)(data, {3217    code: import_smithy_client.expectString,3218    detailedMessage: import_smithy_client.expectString,3219    requestId: import_smithy_client.expectString3220  });3221  Object.assign(contents, doc);3222  const exception = new LoadUrlAccessDeniedException({3223    $metadata: deserializeMetadata(parsedOutput),3224    ...contents3225  });3226  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3227}, "de_LoadUrlAccessDeniedExceptionRes");3228var de_MalformedQueryExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3229  const contents = (0, import_smithy_client.map)({});3230  const data = parsedOutput.body;3231  const doc = (0, import_smithy_client.take)(data, {3232    code: import_smithy_client.expectString,3233    detailedMessage: import_smithy_client.expectString,3234    requestId: import_smithy_client.expectString3235  });3236  Object.assign(contents, doc);3237  const exception = new MalformedQueryException({3238    $metadata: deserializeMetadata(parsedOutput),3239    ...contents3240  });3241  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3242}, "de_MalformedQueryExceptionRes");3243var de_MemoryLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3244  const contents = (0, import_smithy_client.map)({});3245  const data = parsedOutput.body;3246  const doc = (0, import_smithy_client.take)(data, {3247    code: import_smithy_client.expectString,3248    detailedMessage: import_smithy_client.expectString,3249    requestId: import_smithy_client.expectString3250  });3251  Object.assign(contents, doc);3252  const exception = new MemoryLimitExceededException({3253    $metadata: deserializeMetadata(parsedOutput),3254    ...contents3255  });3256  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3257}, "de_MemoryLimitExceededExceptionRes");3258var de_MethodNotAllowedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3259  const contents = (0, import_smithy_client.map)({});3260  const data = parsedOutput.body;3261  const doc = (0, import_smithy_client.take)(data, {3262    code: import_smithy_client.expectString,3263    detailedMessage: import_smithy_client.expectString,3264    requestId: import_smithy_client.expectString3265  });3266  Object.assign(contents, doc);3267  const exception = new MethodNotAllowedException({3268    $metadata: deserializeMetadata(parsedOutput),3269    ...contents3270  });3271  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3272}, "de_MethodNotAllowedExceptionRes");3273var de_MissingParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3274  const contents = (0, import_smithy_client.map)({});3275  const data = parsedOutput.body;3276  const doc = (0, import_smithy_client.take)(data, {3277    code: import_smithy_client.expectString,3278    detailedMessage: import_smithy_client.expectString,3279    requestId: import_smithy_client.expectString3280  });3281  Object.assign(contents, doc);3282  const exception = new MissingParameterException({3283    $metadata: deserializeMetadata(parsedOutput),3284    ...contents3285  });3286  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3287}, "de_MissingParameterExceptionRes");3288var de_MLResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3289  const contents = (0, import_smithy_client.map)({});3290  const data = parsedOutput.body;3291  const doc = (0, import_smithy_client.take)(data, {3292    code: import_smithy_client.expectString,3293    detailedMessage: import_smithy_client.expectString,3294    requestId: import_smithy_client.expectString3295  });3296  Object.assign(contents, doc);3297  const exception = new MLResourceNotFoundException({3298    $metadata: deserializeMetadata(parsedOutput),3299    ...contents3300  });3301  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3302}, "de_MLResourceNotFoundExceptionRes");3303var de_ParsingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3304  const contents = (0, import_smithy_client.map)({});3305  const data = parsedOutput.body;3306  const doc = (0, import_smithy_client.take)(data, {3307    code: import_smithy_client.expectString,3308    detailedMessage: import_smithy_client.expectString,3309    requestId: import_smithy_client.expectString3310  });3311  Object.assign(contents, doc);3312  const exception = new ParsingException({3313    $metadata: deserializeMetadata(parsedOutput),3314    ...contents3315  });3316  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3317}, "de_ParsingExceptionRes");3318var de_PreconditionsFailedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3319  const contents = (0, import_smithy_client.map)({});3320  const data = parsedOutput.body;3321  const doc = (0, import_smithy_client.take)(data, {3322    code: import_smithy_client.expectString,3323    detailedMessage: import_smithy_client.expectString,3324    requestId: import_smithy_client.expectString3325  });3326  Object.assign(contents, doc);3327  const exception = new PreconditionsFailedException({3328    $metadata: deserializeMetadata(parsedOutput),3329    ...contents3330  });3331  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3332}, "de_PreconditionsFailedExceptionRes");3333var de_QueryLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3334  const contents = (0, import_smithy_client.map)({});3335  const data = parsedOutput.body;3336  const doc = (0, import_smithy_client.take)(data, {3337    code: import_smithy_client.expectString,3338    detailedMessage: import_smithy_client.expectString,3339    requestId: import_smithy_client.expectString3340  });3341  Object.assign(contents, doc);3342  const exception = new QueryLimitExceededException({3343    $metadata: deserializeMetadata(parsedOutput),3344    ...contents3345  });3346  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3347}, "de_QueryLimitExceededExceptionRes");3348var de_QueryLimitExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3349  const contents = (0, import_smithy_client.map)({});3350  const data = parsedOutput.body;3351  const doc = (0, import_smithy_client.take)(data, {3352    code: import_smithy_client.expectString,3353    detailedMessage: import_smithy_client.expectString,3354    requestId: import_smithy_client.expectString3355  });3356  Object.assign(contents, doc);3357  const exception = new QueryLimitException({3358    $metadata: deserializeMetadata(parsedOutput),3359    ...contents3360  });3361  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3362}, "de_QueryLimitExceptionRes");3363var de_QueryTooLargeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3364  const contents = (0, import_smithy_client.map)({});3365  const data = parsedOutput.body;3366  const doc = (0, import_smithy_client.take)(data, {3367    code: import_smithy_client.expectString,3368    detailedMessage: import_smithy_client.expectString,3369    requestId: import_smithy_client.expectString3370  });3371  Object.assign(contents, doc);3372  const exception = new QueryTooLargeException({3373    $metadata: deserializeMetadata(parsedOutput),3374    ...contents3375  });3376  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3377}, "de_QueryTooLargeExceptionRes");3378var de_ReadOnlyViolationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3379  const contents = (0, import_smithy_client.map)({});3380  const data = parsedOutput.body;3381  const doc = (0, import_smithy_client.take)(data, {3382    code: import_smithy_client.expectString,3383    detailedMessage: import_smithy_client.expectString,3384    requestId: import_smithy_client.expectString3385  });3386  Object.assign(contents, doc);3387  const exception = new ReadOnlyViolationException({3388    $metadata: deserializeMetadata(parsedOutput),3389    ...contents3390  });3391  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3392}, "de_ReadOnlyViolationExceptionRes");3393var de_S3ExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3394  const contents = (0, import_smithy_client.map)({});3395  const data = parsedOutput.body;3396  const doc = (0, import_smithy_client.take)(data, {3397    code: import_smithy_client.expectString,3398    detailedMessage: import_smithy_client.expectString,3399    requestId: import_smithy_client.expectString3400  });3401  Object.assign(contents, doc);3402  const exception = new S3Exception({3403    $metadata: deserializeMetadata(parsedOutput),3404    ...contents3405  });3406  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3407}, "de_S3ExceptionRes");3408var de_ServerShutdownExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3409  const contents = (0, import_smithy_client.map)({});3410  const data = parsedOutput.body;3411  const doc = (0, import_smithy_client.take)(data, {3412    code: import_smithy_client.expectString,3413    detailedMessage: import_smithy_client.expectString,3414    requestId: import_smithy_client.expectString3415  });3416  Object.assign(contents, doc);3417  const exception = new ServerShutdownException({3418    $metadata: deserializeMetadata(parsedOutput),3419    ...contents3420  });3421  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3422}, "de_ServerShutdownExceptionRes");3423var de_StatisticsNotAvailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3424  const contents = (0, import_smithy_client.map)({});3425  const data = parsedOutput.body;3426  const doc = (0, import_smithy_client.take)(data, {3427    code: import_smithy_client.expectString,3428    detailedMessage: import_smithy_client.expectString,3429    requestId: import_smithy_client.expectString3430  });3431  Object.assign(contents, doc);3432  const exception = new StatisticsNotAvailableException({3433    $metadata: deserializeMetadata(parsedOutput),3434    ...contents3435  });3436  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3437}, "de_StatisticsNotAvailableExceptionRes");3438var de_StreamRecordsNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3439  const contents = (0, import_smithy_client.map)({});3440  const data = parsedOutput.body;3441  const doc = (0, import_smithy_client.take)(data, {3442    code: import_smithy_client.expectString,3443    detailedMessage: import_smithy_client.expectString,3444    requestId: import_smithy_client.expectString3445  });3446  Object.assign(contents, doc);3447  const exception = new StreamRecordsNotFoundException({3448    $metadata: deserializeMetadata(parsedOutput),3449    ...contents3450  });3451  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3452}, "de_StreamRecordsNotFoundExceptionRes");3453var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3454  const contents = (0, import_smithy_client.map)({});3455  const data = parsedOutput.body;3456  const doc = (0, import_smithy_client.take)(data, {3457    code: import_smithy_client.expectString,3458    detailedMessage: import_smithy_client.expectString,3459    requestId: import_smithy_client.expectString3460  });3461  Object.assign(contents, doc);3462  const exception = new ThrottlingException({3463    $metadata: deserializeMetadata(parsedOutput),3464    ...contents3465  });3466  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3467}, "de_ThrottlingExceptionRes");3468var de_TimeLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3469  const contents = (0, import_smithy_client.map)({});3470  const data = parsedOutput.body;3471  const doc = (0, import_smithy_client.take)(data, {3472    code: import_smithy_client.expectString,3473    detailedMessage: import_smithy_client.expectString,3474    requestId: import_smithy_client.expectString3475  });3476  Object.assign(contents, doc);3477  const exception = new TimeLimitExceededException({3478    $metadata: deserializeMetadata(parsedOutput),3479    ...contents3480  });3481  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3482}, "de_TimeLimitExceededExceptionRes");3483var de_TooManyRequestsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3484  const contents = (0, import_smithy_client.map)({});3485  const data = parsedOutput.body;3486  const doc = (0, import_smithy_client.take)(data, {3487    code: import_smithy_client.expectString,3488    detailedMessage: import_smithy_client.expectString,3489    requestId: import_smithy_client.expectString3490  });3491  Object.assign(contents, doc);3492  const exception = new TooManyRequestsException({3493    $metadata: deserializeMetadata(parsedOutput),3494    ...contents3495  });3496  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3497}, "de_TooManyRequestsExceptionRes");3498var de_UnsupportedOperationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {3499  const contents = (0, import_smithy_client.map)({});3500  const data = parsedOutput.body;3501  const doc = (0, import_smithy_client.take)(data, {3502    code: import_smithy_client.expectString,3503    detailedMessage: import_smithy_client.expectString,3504    requestId: import_smithy_client.expectString3505  });3506  Object.assign(contents, doc);3507  const exception = new UnsupportedOperationException({3508    $metadata: deserializeMetadata(parsedOutput),3509    ...contents3510  });3511  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);3512}, "de_UnsupportedOperationExceptionRes");3513var de_DocumentValuedMap = /* @__PURE__ */ __name((output, context) => {3514  return Object.entries(output).reduce((acc, [key, value]) => {3515    if (value === null) {3516      return acc;3517    }3518    acc[key] = de_Document(value, context);3519    return acc;3520  }, {});3521}, "de_DocumentValuedMap");3522var de_GremlinQueries = /* @__PURE__ */ __name((output, context) => {3523  const retVal = (output || []).filter((e) => e != null).map((entry) => {3524    return de_GremlinQueryStatus(entry, context);3525  });3526  return retVal;3527}, "de_GremlinQueries");3528var de_GremlinQueryStatus = /* @__PURE__ */ __name((output, context) => {3529  return (0, import_smithy_client.take)(output, {3530    queryEvalStats: /* @__PURE__ */ __name((_) => de_QueryEvalStats(_, context), "queryEvalStats"),3531    queryId: import_smithy_client.expectString,3532    queryString: import_smithy_client.expectString3533  });3534}, "de_GremlinQueryStatus");3535var de_GremlinQueryStatusAttributes = /* @__PURE__ */ __name((output, context) => {3536  return (0, import_smithy_client.take)(output, {3537    attributes: /* @__PURE__ */ __name((_) => de_Document(_, context), "attributes"),3538    code: import_smithy_client.expectInt32,3539    message: import_smithy_client.expectString3540  });3541}, "de_GremlinQueryStatusAttributes");3542var de_OpenCypherQueries = /* @__PURE__ */ __name((output, context) => {3543  const retVal = (output || []).filter((e) => e != null).map((entry) => {3544    return de_GremlinQueryStatus(entry, context);3545  });3546  return retVal;3547}, "de_OpenCypherQueries");3548var de_PropertygraphData = /* @__PURE__ */ __name((output, context) => {3549  return (0, import_smithy_client.take)(output, {3550    from: import_smithy_client.expectString,3551    id: import_smithy_client.expectString,3552    key: import_smithy_client.expectString,3553    to: import_smithy_client.expectString,3554    type: import_smithy_client.expectString,3555    value: /* @__PURE__ */ __name((_) => de_Document(_, context), "value")3556  });3557}, "de_PropertygraphData");3558var de_PropertygraphRecord = /* @__PURE__ */ __name((output, context) => {3559  return (0, import_smithy_client.take)(output, {3560    commitTimestampInMillis: [, import_smithy_client.expectLong, `commitTimestamp`],3561    data: /* @__PURE__ */ __name((_) => de_PropertygraphData(_, context), "data"),3562    eventId: import_smithy_client._json,3563    isLastOp: import_smithy_client.expectBoolean,3564    op: import_smithy_client.expectString3565  });3566}, "de_PropertygraphRecord");3567var de_PropertygraphRecordsList = /* @__PURE__ */ __name((output, context) => {3568  const retVal = (output || []).filter((e) => e != null).map((entry) => {3569    return de_PropertygraphRecord(entry, context);3570  });3571  return retVal;3572}, "de_PropertygraphRecordsList");3573var de_PropertygraphSummaryValueMap = /* @__PURE__ */ __name((output, context) => {3574  return (0, import_smithy_client.take)(output, {3575    graphSummary: import_smithy_client._json,3576    lastStatisticsComputationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "lastStatisticsComputationTime"),3577    version: import_smithy_client.expectString3578  });3579}, "de_PropertygraphSummaryValueMap");3580var de_QueryEvalStats = /* @__PURE__ */ __name((output, context) => {3581  return (0, import_smithy_client.take)(output, {3582    cancelled: import_smithy_client.expectBoolean,3583    elapsed: import_smithy_client.expectInt32,3584    subqueries: /* @__PURE__ */ __name((_) => de_Document(_, context), "subqueries"),3585    waited: import_smithy_client.expectInt323586  });3587}, "de_QueryEvalStats");3588var de_RDFGraphSummaryValueMap = /* @__PURE__ */ __name((output, context) => {3589  return (0, import_smithy_client.take)(output, {3590    graphSummary: import_smithy_client._json,3591    lastStatisticsComputationTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "lastStatisticsComputationTime"),3592    version: import_smithy_client.expectString3593  });3594}, "de_RDFGraphSummaryValueMap");3595var de_SparqlRecord = /* @__PURE__ */ __name((output, context) => {3596  return (0, import_smithy_client.take)(output, {3597    commitTimestampInMillis: [, import_smithy_client.expectLong, `commitTimestamp`],3598    data: import_smithy_client._json,3599    eventId: import_smithy_client._json,3600    isLastOp: import_smithy_client.expectBoolean,3601    op: import_smithy_client.expectString3602  });3603}, "de_SparqlRecord");3604var de_SparqlRecordsList = /* @__PURE__ */ __name((output, context) => {3605  const retVal = (output || []).filter((e) => e != null).map((entry) => {3606    return de_SparqlRecord(entry, context);3607  });3608  return retVal;3609}, "de_SparqlRecordsList");3610var de_Statistics = /* @__PURE__ */ __name((output, context) => {3611  return (0, import_smithy_client.take)(output, {3612    active: import_smithy_client.expectBoolean,3613    autoCompute: import_smithy_client.expectBoolean,3614    date: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "date"),3615    note: import_smithy_client.expectString,3616    signatureInfo: import_smithy_client._json,3617    statisticsId: import_smithy_client.expectString3618  });3619}, "de_Statistics");3620var de_Document = /* @__PURE__ */ __name((output, context) => {3621  return output;3622}, "de_Document");3623var deserializeMetadata = /* @__PURE__ */ __name((output) => ({3624  httpStatusCode: output.statusCode,3625  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],3626  extendedRequestId: output.headers["x-amz-id-2"],3627  cfId: output.headers["x-amz-cf-id"]3628}), "deserializeMetadata");3629var _a = "accept";3630var _ae = "accept-encoding";3631var _c = "clean";3632var _cN = "commitNum";3633var _d = "details";3634var _e = "errors";3635var _ePP = "errorsPerPage";3636var _en = "encoding";3637var _iQL = "includeQueuedLoads";3638var _iT = "iteratorType";3639var _iW = "includeWaiting";3640var _l = "limit";3641var _m = "mode";3642var _mI = "maxItems";3643var _nIRA = "neptuneIamRoleArn";3644var _oN = "opNum";3645var _p = "page";3646var _s = "silent";3647var _se = "serializer";3648 3649// src/commands/CancelGremlinQueryCommand.ts3650var CancelGremlinQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3651  return [3652    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3653    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3654  ];3655}).s("AmazonNeptuneDataplane", "CancelGremlinQuery", {}).n("NeptunedataClient", "CancelGremlinQueryCommand").f(void 0, void 0).ser(se_CancelGremlinQueryCommand).de(de_CancelGremlinQueryCommand).build() {3656  static {3657    __name(this, "CancelGremlinQueryCommand");3658  }3659};3660 3661// src/commands/CancelLoaderJobCommand.ts3662 3663 3664 3665var CancelLoaderJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3666  return [3667    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3668    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3669  ];3670}).s("AmazonNeptuneDataplane", "CancelLoaderJob", {}).n("NeptunedataClient", "CancelLoaderJobCommand").f(void 0, void 0).ser(se_CancelLoaderJobCommand).de(de_CancelLoaderJobCommand).build() {3671  static {3672    __name(this, "CancelLoaderJobCommand");3673  }3674};3675 3676// src/commands/CancelMLDataProcessingJobCommand.ts3677 3678 3679 3680var CancelMLDataProcessingJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3681  return [3682    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3683    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3684  ];3685}).s("AmazonNeptuneDataplane", "CancelMLDataProcessingJob", {}).n("NeptunedataClient", "CancelMLDataProcessingJobCommand").f(void 0, void 0).ser(se_CancelMLDataProcessingJobCommand).de(de_CancelMLDataProcessingJobCommand).build() {3686  static {3687    __name(this, "CancelMLDataProcessingJobCommand");3688  }3689};3690 3691// src/commands/CancelMLModelTrainingJobCommand.ts3692 3693 3694 3695var CancelMLModelTrainingJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3696  return [3697    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3698    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3699  ];3700}).s("AmazonNeptuneDataplane", "CancelMLModelTrainingJob", {}).n("NeptunedataClient", "CancelMLModelTrainingJobCommand").f(void 0, void 0).ser(se_CancelMLModelTrainingJobCommand).de(de_CancelMLModelTrainingJobCommand).build() {3701  static {3702    __name(this, "CancelMLModelTrainingJobCommand");3703  }3704};3705 3706// src/commands/CancelMLModelTransformJobCommand.ts3707 3708 3709 3710var CancelMLModelTransformJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3711  return [3712    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3713    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3714  ];3715}).s("AmazonNeptuneDataplane", "CancelMLModelTransformJob", {}).n("NeptunedataClient", "CancelMLModelTransformJobCommand").f(void 0, void 0).ser(se_CancelMLModelTransformJobCommand).de(de_CancelMLModelTransformJobCommand).build() {3716  static {3717    __name(this, "CancelMLModelTransformJobCommand");3718  }3719};3720 3721// src/commands/CancelOpenCypherQueryCommand.ts3722 3723 3724 3725var CancelOpenCypherQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3726  return [3727    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3728    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3729  ];3730}).s("AmazonNeptuneDataplane", "CancelOpenCypherQuery", {}).n("NeptunedataClient", "CancelOpenCypherQueryCommand").f(void 0, void 0).ser(se_CancelOpenCypherQueryCommand).de(de_CancelOpenCypherQueryCommand).build() {3731  static {3732    __name(this, "CancelOpenCypherQueryCommand");3733  }3734};3735 3736// src/commands/CreateMLEndpointCommand.ts3737 3738 3739 3740var CreateMLEndpointCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3741  return [3742    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3743    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3744  ];3745}).s("AmazonNeptuneDataplane", "CreateMLEndpoint", {}).n("NeptunedataClient", "CreateMLEndpointCommand").f(void 0, void 0).ser(se_CreateMLEndpointCommand).de(de_CreateMLEndpointCommand).build() {3746  static {3747    __name(this, "CreateMLEndpointCommand");3748  }3749};3750 3751// src/commands/DeleteMLEndpointCommand.ts3752 3753 3754 3755var DeleteMLEndpointCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3756  return [3757    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3758    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3759  ];3760}).s("AmazonNeptuneDataplane", "DeleteMLEndpoint", {}).n("NeptunedataClient", "DeleteMLEndpointCommand").f(void 0, void 0).ser(se_DeleteMLEndpointCommand).de(de_DeleteMLEndpointCommand).build() {3761  static {3762    __name(this, "DeleteMLEndpointCommand");3763  }3764};3765 3766// src/commands/DeletePropertygraphStatisticsCommand.ts3767 3768 3769 3770var DeletePropertygraphStatisticsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3771  return [3772    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3773    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3774  ];3775}).s("AmazonNeptuneDataplane", "DeletePropertygraphStatistics", {}).n("NeptunedataClient", "DeletePropertygraphStatisticsCommand").f(void 0, void 0).ser(se_DeletePropertygraphStatisticsCommand).de(de_DeletePropertygraphStatisticsCommand).build() {3776  static {3777    __name(this, "DeletePropertygraphStatisticsCommand");3778  }3779};3780 3781// src/commands/DeleteSparqlStatisticsCommand.ts3782 3783 3784 3785var DeleteSparqlStatisticsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3786  return [3787    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3788    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3789  ];3790}).s("AmazonNeptuneDataplane", "DeleteSparqlStatistics", {}).n("NeptunedataClient", "DeleteSparqlStatisticsCommand").f(void 0, void 0).ser(se_DeleteSparqlStatisticsCommand).de(de_DeleteSparqlStatisticsCommand).build() {3791  static {3792    __name(this, "DeleteSparqlStatisticsCommand");3793  }3794};3795 3796// src/commands/ExecuteFastResetCommand.ts3797 3798 3799 3800var ExecuteFastResetCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3801  return [3802    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3803    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3804  ];3805}).s("AmazonNeptuneDataplane", "ExecuteFastReset", {}).n("NeptunedataClient", "ExecuteFastResetCommand").f(void 0, void 0).ser(se_ExecuteFastResetCommand).de(de_ExecuteFastResetCommand).build() {3806  static {3807    __name(this, "ExecuteFastResetCommand");3808  }3809};3810 3811// src/commands/ExecuteGremlinExplainQueryCommand.ts3812 3813 3814 3815var ExecuteGremlinExplainQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3816  return [3817    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3818    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3819  ];3820}).s("AmazonNeptuneDataplane", "ExecuteGremlinExplainQuery", {}).n("NeptunedataClient", "ExecuteGremlinExplainQueryCommand").f(void 0, void 0).ser(se_ExecuteGremlinExplainQueryCommand).de(de_ExecuteGremlinExplainQueryCommand).build() {3821  static {3822    __name(this, "ExecuteGremlinExplainQueryCommand");3823  }3824};3825 3826// src/commands/ExecuteGremlinProfileQueryCommand.ts3827 3828 3829 3830var ExecuteGremlinProfileQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3831  return [3832    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3833    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3834  ];3835}).s("AmazonNeptuneDataplane", "ExecuteGremlinProfileQuery", {}).n("NeptunedataClient", "ExecuteGremlinProfileQueryCommand").f(void 0, void 0).ser(se_ExecuteGremlinProfileQueryCommand).de(de_ExecuteGremlinProfileQueryCommand).build() {3836  static {3837    __name(this, "ExecuteGremlinProfileQueryCommand");3838  }3839};3840 3841// src/commands/ExecuteGremlinQueryCommand.ts3842 3843 3844 3845var ExecuteGremlinQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3846  return [3847    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3848    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3849  ];3850}).s("AmazonNeptuneDataplane", "ExecuteGremlinQuery", {}).n("NeptunedataClient", "ExecuteGremlinQueryCommand").f(void 0, void 0).ser(se_ExecuteGremlinQueryCommand).de(de_ExecuteGremlinQueryCommand).build() {3851  static {3852    __name(this, "ExecuteGremlinQueryCommand");3853  }3854};3855 3856// src/commands/ExecuteOpenCypherExplainQueryCommand.ts3857 3858 3859 3860var ExecuteOpenCypherExplainQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3861  return [3862    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3863    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3864  ];3865}).s("AmazonNeptuneDataplane", "ExecuteOpenCypherExplainQuery", {}).n("NeptunedataClient", "ExecuteOpenCypherExplainQueryCommand").f(void 0, void 0).ser(se_ExecuteOpenCypherExplainQueryCommand).de(de_ExecuteOpenCypherExplainQueryCommand).build() {3866  static {3867    __name(this, "ExecuteOpenCypherExplainQueryCommand");3868  }3869};3870 3871// src/commands/ExecuteOpenCypherQueryCommand.ts3872 3873 3874 3875var ExecuteOpenCypherQueryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3876  return [3877    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3878    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3879  ];3880}).s("AmazonNeptuneDataplane", "ExecuteOpenCypherQuery", {}).n("NeptunedataClient", "ExecuteOpenCypherQueryCommand").f(void 0, void 0).ser(se_ExecuteOpenCypherQueryCommand).de(de_ExecuteOpenCypherQueryCommand).build() {3881  static {3882    __name(this, "ExecuteOpenCypherQueryCommand");3883  }3884};3885 3886// src/commands/GetEngineStatusCommand.ts3887 3888 3889 3890var GetEngineStatusCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3891  return [3892    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3893    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3894  ];3895}).s("AmazonNeptuneDataplane", "GetEngineStatus", {}).n("NeptunedataClient", "GetEngineStatusCommand").f(void 0, void 0).ser(se_GetEngineStatusCommand).de(de_GetEngineStatusCommand).build() {3896  static {3897    __name(this, "GetEngineStatusCommand");3898  }3899};3900 3901// src/commands/GetGremlinQueryStatusCommand.ts3902 3903 3904 3905var GetGremlinQueryStatusCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3906  return [3907    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3908    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3909  ];3910}).s("AmazonNeptuneDataplane", "GetGremlinQueryStatus", {}).n("NeptunedataClient", "GetGremlinQueryStatusCommand").f(void 0, void 0).ser(se_GetGremlinQueryStatusCommand).de(de_GetGremlinQueryStatusCommand).build() {3911  static {3912    __name(this, "GetGremlinQueryStatusCommand");3913  }3914};3915 3916// src/commands/GetLoaderJobStatusCommand.ts3917 3918 3919 3920var GetLoaderJobStatusCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3921  return [3922    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3923    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3924  ];3925}).s("AmazonNeptuneDataplane", "GetLoaderJobStatus", {}).n("NeptunedataClient", "GetLoaderJobStatusCommand").f(void 0, void 0).ser(se_GetLoaderJobStatusCommand).de(de_GetLoaderJobStatusCommand).build() {3926  static {3927    __name(this, "GetLoaderJobStatusCommand");3928  }3929};3930 3931// src/commands/GetMLDataProcessingJobCommand.ts3932 3933 3934 3935var GetMLDataProcessingJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3936  return [3937    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3938    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3939  ];3940}).s("AmazonNeptuneDataplane", "GetMLDataProcessingJob", {}).n("NeptunedataClient", "GetMLDataProcessingJobCommand").f(void 0, void 0).ser(se_GetMLDataProcessingJobCommand).de(de_GetMLDataProcessingJobCommand).build() {3941  static {3942    __name(this, "GetMLDataProcessingJobCommand");3943  }3944};3945 3946// src/commands/GetMLEndpointCommand.ts3947 3948 3949 3950var GetMLEndpointCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3951  return [3952    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3953    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3954  ];3955}).s("AmazonNeptuneDataplane", "GetMLEndpoint", {}).n("NeptunedataClient", "GetMLEndpointCommand").f(void 0, void 0).ser(se_GetMLEndpointCommand).de(de_GetMLEndpointCommand).build() {3956  static {3957    __name(this, "GetMLEndpointCommand");3958  }3959};3960 3961// src/commands/GetMLModelTrainingJobCommand.ts3962 3963 3964 3965var GetMLModelTrainingJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3966  return [3967    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3968    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3969  ];3970}).s("AmazonNeptuneDataplane", "GetMLModelTrainingJob", {}).n("NeptunedataClient", "GetMLModelTrainingJobCommand").f(void 0, void 0).ser(se_GetMLModelTrainingJobCommand).de(de_GetMLModelTrainingJobCommand).build() {3971  static {3972    __name(this, "GetMLModelTrainingJobCommand");3973  }3974};3975 3976// src/commands/GetMLModelTransformJobCommand.ts3977 3978 3979 3980var GetMLModelTransformJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3981  return [3982    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3983    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3984  ];3985}).s("AmazonNeptuneDataplane", "GetMLModelTransformJob", {}).n("NeptunedataClient", "GetMLModelTransformJobCommand").f(void 0, void 0).ser(se_GetMLModelTransformJobCommand).de(de_GetMLModelTransformJobCommand).build() {3986  static {3987    __name(this, "GetMLModelTransformJobCommand");3988  }3989};3990 3991// src/commands/GetOpenCypherQueryStatusCommand.ts3992 3993 3994 3995var GetOpenCypherQueryStatusCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {3996  return [3997    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),3998    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())3999  ];4000}).s("AmazonNeptuneDataplane", "GetOpenCypherQueryStatus", {}).n("NeptunedataClient", "GetOpenCypherQueryStatusCommand").f(void 0, void 0).ser(se_GetOpenCypherQueryStatusCommand).de(de_GetOpenCypherQueryStatusCommand).build() {4001  static {4002    __name(this, "GetOpenCypherQueryStatusCommand");4003  }4004};4005 4006// src/commands/GetPropertygraphStatisticsCommand.ts4007 4008 4009 4010var GetPropertygraphStatisticsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4011  return [4012    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4013    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4014  ];4015}).s("AmazonNeptuneDataplane", "GetPropertygraphStatistics", {}).n("NeptunedataClient", "GetPropertygraphStatisticsCommand").f(void 0, void 0).ser(se_GetPropertygraphStatisticsCommand).de(de_GetPropertygraphStatisticsCommand).build() {4016  static {4017    __name(this, "GetPropertygraphStatisticsCommand");4018  }4019};4020 4021// src/commands/GetPropertygraphStreamCommand.ts4022 4023 4024 4025var GetPropertygraphStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4026  return [4027    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4028    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4029  ];4030}).s("AmazonNeptuneDataplane", "GetPropertygraphStream", {}).n("NeptunedataClient", "GetPropertygraphStreamCommand").f(void 0, void 0).ser(se_GetPropertygraphStreamCommand).de(de_GetPropertygraphStreamCommand).build() {4031  static {4032    __name(this, "GetPropertygraphStreamCommand");4033  }4034};4035 4036// src/commands/GetPropertygraphSummaryCommand.ts4037 4038 4039 4040var GetPropertygraphSummaryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4041  return [4042    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4043    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4044  ];4045}).s("AmazonNeptuneDataplane", "GetPropertygraphSummary", {}).n("NeptunedataClient", "GetPropertygraphSummaryCommand").f(void 0, void 0).ser(se_GetPropertygraphSummaryCommand).de(de_GetPropertygraphSummaryCommand).build() {4046  static {4047    __name(this, "GetPropertygraphSummaryCommand");4048  }4049};4050 4051// src/commands/GetRDFGraphSummaryCommand.ts4052 4053 4054 4055var GetRDFGraphSummaryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4056  return [4057    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4058    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4059  ];4060}).s("AmazonNeptuneDataplane", "GetRDFGraphSummary", {}).n("NeptunedataClient", "GetRDFGraphSummaryCommand").f(void 0, void 0).ser(se_GetRDFGraphSummaryCommand).de(de_GetRDFGraphSummaryCommand).build() {4061  static {4062    __name(this, "GetRDFGraphSummaryCommand");4063  }4064};4065 4066// src/commands/GetSparqlStatisticsCommand.ts4067 4068 4069 4070var GetSparqlStatisticsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4071  return [4072    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4073    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4074  ];4075}).s("AmazonNeptuneDataplane", "GetSparqlStatistics", {}).n("NeptunedataClient", "GetSparqlStatisticsCommand").f(void 0, void 0).ser(se_GetSparqlStatisticsCommand).de(de_GetSparqlStatisticsCommand).build() {4076  static {4077    __name(this, "GetSparqlStatisticsCommand");4078  }4079};4080 4081// src/commands/GetSparqlStreamCommand.ts4082 4083 4084 4085var GetSparqlStreamCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4086  return [4087    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4088    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4089  ];4090}).s("AmazonNeptuneDataplane", "GetSparqlStream", {}).n("NeptunedataClient", "GetSparqlStreamCommand").f(void 0, void 0).ser(se_GetSparqlStreamCommand).de(de_GetSparqlStreamCommand).build() {4091  static {4092    __name(this, "GetSparqlStreamCommand");4093  }4094};4095 4096// src/commands/ListGremlinQueriesCommand.ts4097 4098 4099 4100var ListGremlinQueriesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4101  return [4102    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4103    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4104  ];4105}).s("AmazonNeptuneDataplane", "ListGremlinQueries", {}).n("NeptunedataClient", "ListGremlinQueriesCommand").f(void 0, void 0).ser(se_ListGremlinQueriesCommand).de(de_ListGremlinQueriesCommand).build() {4106  static {4107    __name(this, "ListGremlinQueriesCommand");4108  }4109};4110 4111// src/commands/ListLoaderJobsCommand.ts4112 4113 4114 4115var ListLoaderJobsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4116  return [4117    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4118    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4119  ];4120}).s("AmazonNeptuneDataplane", "ListLoaderJobs", {}).n("NeptunedataClient", "ListLoaderJobsCommand").f(void 0, void 0).ser(se_ListLoaderJobsCommand).de(de_ListLoaderJobsCommand).build() {4121  static {4122    __name(this, "ListLoaderJobsCommand");4123  }4124};4125 4126// src/commands/ListMLDataProcessingJobsCommand.ts4127 4128 4129 4130var ListMLDataProcessingJobsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4131  return [4132    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4133    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4134  ];4135}).s("AmazonNeptuneDataplane", "ListMLDataProcessingJobs", {}).n("NeptunedataClient", "ListMLDataProcessingJobsCommand").f(void 0, void 0).ser(se_ListMLDataProcessingJobsCommand).de(de_ListMLDataProcessingJobsCommand).build() {4136  static {4137    __name(this, "ListMLDataProcessingJobsCommand");4138  }4139};4140 4141// src/commands/ListMLEndpointsCommand.ts4142 4143 4144 4145var ListMLEndpointsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4146  return [4147    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4148    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4149  ];4150}).s("AmazonNeptuneDataplane", "ListMLEndpoints", {}).n("NeptunedataClient", "ListMLEndpointsCommand").f(void 0, void 0).ser(se_ListMLEndpointsCommand).de(de_ListMLEndpointsCommand).build() {4151  static {4152    __name(this, "ListMLEndpointsCommand");4153  }4154};4155 4156// src/commands/ListMLModelTrainingJobsCommand.ts4157 4158 4159 4160var ListMLModelTrainingJobsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4161  return [4162    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4163    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4164  ];4165}).s("AmazonNeptuneDataplane", "ListMLModelTrainingJobs", {}).n("NeptunedataClient", "ListMLModelTrainingJobsCommand").f(void 0, void 0).ser(se_ListMLModelTrainingJobsCommand).de(de_ListMLModelTrainingJobsCommand).build() {4166  static {4167    __name(this, "ListMLModelTrainingJobsCommand");4168  }4169};4170 4171// src/commands/ListMLModelTransformJobsCommand.ts4172 4173 4174 4175var ListMLModelTransformJobsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4176  return [4177    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4178    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4179  ];4180}).s("AmazonNeptuneDataplane", "ListMLModelTransformJobs", {}).n("NeptunedataClient", "ListMLModelTransformJobsCommand").f(void 0, void 0).ser(se_ListMLModelTransformJobsCommand).de(de_ListMLModelTransformJobsCommand).build() {4181  static {4182    __name(this, "ListMLModelTransformJobsCommand");4183  }4184};4185 4186// src/commands/ListOpenCypherQueriesCommand.ts4187 4188 4189 4190var ListOpenCypherQueriesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4191  return [4192    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4193    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4194  ];4195}).s("AmazonNeptuneDataplane", "ListOpenCypherQueries", {}).n("NeptunedataClient", "ListOpenCypherQueriesCommand").f(void 0, void 0).ser(se_ListOpenCypherQueriesCommand).de(de_ListOpenCypherQueriesCommand).build() {4196  static {4197    __name(this, "ListOpenCypherQueriesCommand");4198  }4199};4200 4201// src/commands/ManagePropertygraphStatisticsCommand.ts4202 4203 4204 4205var ManagePropertygraphStatisticsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4206  return [4207    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4208    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4209  ];4210}).s("AmazonNeptuneDataplane", "ManagePropertygraphStatistics", {}).n("NeptunedataClient", "ManagePropertygraphStatisticsCommand").f(void 0, void 0).ser(se_ManagePropertygraphStatisticsCommand).de(de_ManagePropertygraphStatisticsCommand).build() {4211  static {4212    __name(this, "ManagePropertygraphStatisticsCommand");4213  }4214};4215 4216// src/commands/ManageSparqlStatisticsCommand.ts4217 4218 4219 4220var ManageSparqlStatisticsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4221  return [4222    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4223    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4224  ];4225}).s("AmazonNeptuneDataplane", "ManageSparqlStatistics", {}).n("NeptunedataClient", "ManageSparqlStatisticsCommand").f(void 0, void 0).ser(se_ManageSparqlStatisticsCommand).de(de_ManageSparqlStatisticsCommand).build() {4226  static {4227    __name(this, "ManageSparqlStatisticsCommand");4228  }4229};4230 4231// src/commands/StartLoaderJobCommand.ts4232 4233 4234 4235var StartLoaderJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4236  return [4237    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4238    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4239  ];4240}).s("AmazonNeptuneDataplane", "StartLoaderJob", {}).n("NeptunedataClient", "StartLoaderJobCommand").f(void 0, void 0).ser(se_StartLoaderJobCommand).de(de_StartLoaderJobCommand).build() {4241  static {4242    __name(this, "StartLoaderJobCommand");4243  }4244};4245 4246// src/commands/StartMLDataProcessingJobCommand.ts4247 4248 4249 4250var StartMLDataProcessingJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4251  return [4252    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4253    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4254  ];4255}).s("AmazonNeptuneDataplane", "StartMLDataProcessingJob", {}).n("NeptunedataClient", "StartMLDataProcessingJobCommand").f(void 0, void 0).ser(se_StartMLDataProcessingJobCommand).de(de_StartMLDataProcessingJobCommand).build() {4256  static {4257    __name(this, "StartMLDataProcessingJobCommand");4258  }4259};4260 4261// src/commands/StartMLModelTrainingJobCommand.ts4262 4263 4264 4265var StartMLModelTrainingJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4266  return [4267    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4268    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4269  ];4270}).s("AmazonNeptuneDataplane", "StartMLModelTrainingJob", {}).n("NeptunedataClient", "StartMLModelTrainingJobCommand").f(void 0, void 0).ser(se_StartMLModelTrainingJobCommand).de(de_StartMLModelTrainingJobCommand).build() {4271  static {4272    __name(this, "StartMLModelTrainingJobCommand");4273  }4274};4275 4276// src/commands/StartMLModelTransformJobCommand.ts4277 4278 4279 4280var StartMLModelTransformJobCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {4281  return [4282    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),4283    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())4284  ];4285}).s("AmazonNeptuneDataplane", "StartMLModelTransformJob", {}).n("NeptunedataClient", "StartMLModelTransformJobCommand").f(void 0, void 0).ser(se_StartMLModelTransformJobCommand).de(de_StartMLModelTransformJobCommand).build() {4286  static {4287    __name(this, "StartMLModelTransformJobCommand");4288  }4289};4290 4291// src/Neptunedata.ts4292var commands = {4293  CancelGremlinQueryCommand,4294  CancelLoaderJobCommand,4295  CancelMLDataProcessingJobCommand,4296  CancelMLModelTrainingJobCommand,4297  CancelMLModelTransformJobCommand,4298  CancelOpenCypherQueryCommand,4299  CreateMLEndpointCommand,4300  DeleteMLEndpointCommand,4301  DeletePropertygraphStatisticsCommand,4302  DeleteSparqlStatisticsCommand,4303  ExecuteFastResetCommand,4304  ExecuteGremlinExplainQueryCommand,4305  ExecuteGremlinProfileQueryCommand,4306  ExecuteGremlinQueryCommand,4307  ExecuteOpenCypherExplainQueryCommand,4308  ExecuteOpenCypherQueryCommand,4309  GetEngineStatusCommand,4310  GetGremlinQueryStatusCommand,4311  GetLoaderJobStatusCommand,4312  GetMLDataProcessingJobCommand,4313  GetMLEndpointCommand,4314  GetMLModelTrainingJobCommand,4315  GetMLModelTransformJobCommand,4316  GetOpenCypherQueryStatusCommand,4317  GetPropertygraphStatisticsCommand,4318  GetPropertygraphStreamCommand,4319  GetPropertygraphSummaryCommand,4320  GetRDFGraphSummaryCommand,4321  GetSparqlStatisticsCommand,4322  GetSparqlStreamCommand,4323  ListGremlinQueriesCommand,4324  ListLoaderJobsCommand,4325  ListMLDataProcessingJobsCommand,4326  ListMLEndpointsCommand,4327  ListMLModelTrainingJobsCommand,4328  ListMLModelTransformJobsCommand,4329  ListOpenCypherQueriesCommand,4330  ManagePropertygraphStatisticsCommand,4331  ManageSparqlStatisticsCommand,4332  StartLoaderJobCommand,4333  StartMLDataProcessingJobCommand,4334  StartMLModelTrainingJobCommand,4335  StartMLModelTransformJobCommand4336};4337var Neptunedata = class extends NeptunedataClient {4338  static {4339    __name(this, "Neptunedata");4340  }4341};4342(0, import_smithy_client.createAggregatedClient)(commands, Neptunedata);4343// Annotate the CommonJS export names for ESM import in node:4344 43450 && (module.exports = {4346  NeptunedataServiceException,4347  __Client,4348  NeptunedataClient,4349  Neptunedata,4350  $Command,4351  CancelGremlinQueryCommand,4352  CancelLoaderJobCommand,4353  CancelMLDataProcessingJobCommand,4354  CancelMLModelTrainingJobCommand,4355  CancelMLModelTransformJobCommand,4356  CancelOpenCypherQueryCommand,4357  CreateMLEndpointCommand,4358  DeleteMLEndpointCommand,4359  DeletePropertygraphStatisticsCommand,4360  DeleteSparqlStatisticsCommand,4361  ExecuteFastResetCommand,4362  ExecuteGremlinExplainQueryCommand,4363  ExecuteGremlinProfileQueryCommand,4364  ExecuteGremlinQueryCommand,4365  ExecuteOpenCypherExplainQueryCommand,4366  ExecuteOpenCypherQueryCommand,4367  GetEngineStatusCommand,4368  GetGremlinQueryStatusCommand,4369  GetLoaderJobStatusCommand,4370  GetMLDataProcessingJobCommand,4371  GetMLEndpointCommand,4372  GetMLModelTrainingJobCommand,4373  GetMLModelTransformJobCommand,4374  GetOpenCypherQueryStatusCommand,4375  GetPropertygraphStatisticsCommand,4376  GetPropertygraphStreamCommand,4377  GetPropertygraphSummaryCommand,4378  GetRDFGraphSummaryCommand,4379  GetSparqlStatisticsCommand,4380  GetSparqlStreamCommand,4381  ListGremlinQueriesCommand,4382  ListLoaderJobsCommand,4383  ListMLDataProcessingJobsCommand,4384  ListMLEndpointsCommand,4385  ListMLModelTrainingJobsCommand,4386  ListMLModelTransformJobsCommand,4387  ListOpenCypherQueriesCommand,4388  ManagePropertygraphStatisticsCommand,4389  ManageSparqlStatisticsCommand,4390  StartLoaderJobCommand,4391  StartMLDataProcessingJobCommand,4392  StartMLModelTrainingJobCommand,4393  StartMLModelTransformJobCommand,4394  AccessDeniedException,4395  Action,4396  BadRequestException,4397  ClientTimeoutException,4398  ConcurrentModificationException,4399  ConstraintViolationException,4400  FailureByQueryException,4401  IllegalArgumentException,4402  InvalidArgumentException,4403  InvalidParameterException,4404  MissingParameterException,4405  ParsingException,4406  PreconditionsFailedException,4407  TimeLimitExceededException,4408  TooManyRequestsException,4409  UnsupportedOperationException,4410  BulkLoadIdNotFoundException,4411  InternalFailureException,4412  LoadUrlAccessDeniedException,4413  MLResourceNotFoundException,4414  InvalidNumericDataException,4415  ReadOnlyViolationException,4416  StatisticsNotAvailableException,4417  MethodNotAllowedException,4418  ServerShutdownException,4419  CancelledByUserException,4420  MalformedQueryException,4421  MemoryLimitExceededException,4422  QueryLimitExceededException,4423  QueryLimitException,4424  QueryTooLargeException,4425  OpenCypherExplainMode,4426  ExpiredStreamException,4427  Encoding,4428  IteratorType,4429  StreamRecordsNotFoundException,4430  ThrottlingException,4431  GraphSummaryType,4432  StatisticsAutoGenerationMode,4433  S3Exception,4434  Format,4435  Mode,4436  Parallelism,4437  S3BucketRegion4438});4439 4440