@aws-sdk/client-rds-data 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,1646 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RDSDataServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./RDSDataClient"), exports);
-tslib_1.__exportStar(require("./RDSData"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var RDSDataServiceException_1 = require("./models/RDSDataServiceException");
-Object.defineProperty(exports, "RDSDataServiceException", { enumerable: true, get: function () { return RDSDataServiceException_1.RDSDataServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  ArrayValue: () => ArrayValue,
+  BadRequestException: () => BadRequestException,
+  BatchExecuteStatementCommand: () => BatchExecuteStatementCommand,
+  BeginTransactionCommand: () => BeginTransactionCommand,
+  CommitTransactionCommand: () => CommitTransactionCommand,
+  DatabaseErrorException: () => DatabaseErrorException,
+  DatabaseNotFoundException: () => DatabaseNotFoundException,
+  DatabaseUnavailableException: () => DatabaseUnavailableException,
+  DecimalReturnType: () => DecimalReturnType,
+  ExecuteSqlCommand: () => ExecuteSqlCommand,
+  ExecuteStatementCommand: () => ExecuteStatementCommand,
+  Field: () => Field,
+  ForbiddenException: () => ForbiddenException,
+  HttpEndpointNotEnabledException: () => HttpEndpointNotEnabledException,
+  InternalServerErrorException: () => InternalServerErrorException,
+  InvalidSecretException: () => InvalidSecretException,
+  LongReturnType: () => LongReturnType,
+  NotFoundException: () => NotFoundException,
+  RDSData: () => RDSData,
+  RDSDataClient: () => RDSDataClient,
+  RDSDataServiceException: () => RDSDataServiceException,
+  RecordsFormatType: () => RecordsFormatType,
+  RollbackTransactionCommand: () => RollbackTransactionCommand,
+  SecretsErrorException: () => SecretsErrorException,
+  ServiceUnavailableError: () => ServiceUnavailableError,
+  StatementTimeoutException: () => StatementTimeoutException,
+  TransactionNotFoundException: () => TransactionNotFoundException,
+  TypeHint: () => TypeHint,
+  UnsupportedResultException: () => UnsupportedResultException,
+  Value: () => Value,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/RDSDataClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "rds-data"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/RDSDataClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/RDSDataClient.ts
+var _RDSDataClient = class _RDSDataClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_RDSDataClient, "RDSDataClient");
+var RDSDataClient = _RDSDataClient;
+
+// src/RDSData.ts
+
+
+// src/commands/BatchExecuteStatementCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@aws-sdk/core");
+var import_core2 = require("@smithy/core");
+
+
+// src/models/RDSDataServiceException.ts
+
+var _RDSDataServiceException = class _RDSDataServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _RDSDataServiceException.prototype);
+  }
+};
+__name(_RDSDataServiceException, "RDSDataServiceException");
+var RDSDataServiceException = _RDSDataServiceException;
+
+// src/models/models_0.ts
+var _AccessDeniedException = class _AccessDeniedException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _BadRequestException = class _BadRequestException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var TypeHint = {
+  DATE: "DATE",
+  DECIMAL: "DECIMAL",
+  JSON: "JSON",
+  TIME: "TIME",
+  TIMESTAMP: "TIMESTAMP",
+  UUID: "UUID"
+};
+var _DatabaseErrorException = class _DatabaseErrorException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DatabaseErrorException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DatabaseErrorException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DatabaseErrorException.prototype);
+  }
+};
+__name(_DatabaseErrorException, "DatabaseErrorException");
+var DatabaseErrorException = _DatabaseErrorException;
+var _DatabaseNotFoundException = class _DatabaseNotFoundException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DatabaseNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DatabaseNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DatabaseNotFoundException.prototype);
+  }
+};
+__name(_DatabaseNotFoundException, "DatabaseNotFoundException");
+var DatabaseNotFoundException = _DatabaseNotFoundException;
+var _DatabaseUnavailableException = class _DatabaseUnavailableException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DatabaseUnavailableException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "DatabaseUnavailableException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _DatabaseUnavailableException.prototype);
+  }
+};
+__name(_DatabaseUnavailableException, "DatabaseUnavailableException");
+var DatabaseUnavailableException = _DatabaseUnavailableException;
+var _ForbiddenException = class _ForbiddenException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ForbiddenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ForbiddenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ForbiddenException.prototype);
+  }
+};
+__name(_ForbiddenException, "ForbiddenException");
+var ForbiddenException = _ForbiddenException;
+var _HttpEndpointNotEnabledException = class _HttpEndpointNotEnabledException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "HttpEndpointNotEnabledException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "HttpEndpointNotEnabledException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _HttpEndpointNotEnabledException.prototype);
+  }
+};
+__name(_HttpEndpointNotEnabledException, "HttpEndpointNotEnabledException");
+var HttpEndpointNotEnabledException = _HttpEndpointNotEnabledException;
+var _InternalServerErrorException = class _InternalServerErrorException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerErrorException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerErrorException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerErrorException.prototype);
+  }
+};
+__name(_InternalServerErrorException, "InternalServerErrorException");
+var InternalServerErrorException = _InternalServerErrorException;
+var _InvalidSecretException = class _InvalidSecretException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidSecretException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidSecretException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidSecretException.prototype);
+  }
+};
+__name(_InvalidSecretException, "InvalidSecretException");
+var InvalidSecretException = _InvalidSecretException;
+var _SecretsErrorException = class _SecretsErrorException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SecretsErrorException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SecretsErrorException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SecretsErrorException.prototype);
+  }
+};
+__name(_SecretsErrorException, "SecretsErrorException");
+var SecretsErrorException = _SecretsErrorException;
+var _ServiceUnavailableError = class _ServiceUnavailableError extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceUnavailableError",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServiceUnavailableError";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _ServiceUnavailableError.prototype);
+  }
+};
+__name(_ServiceUnavailableError, "ServiceUnavailableError");
+var ServiceUnavailableError = _ServiceUnavailableError;
+var _StatementTimeoutException = class _StatementTimeoutException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "StatementTimeoutException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "StatementTimeoutException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _StatementTimeoutException.prototype);
+    this.dbConnectionId = opts.dbConnectionId;
+  }
+};
+__name(_StatementTimeoutException, "StatementTimeoutException");
+var StatementTimeoutException = _StatementTimeoutException;
+var _TransactionNotFoundException = class _TransactionNotFoundException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TransactionNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TransactionNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TransactionNotFoundException.prototype);
+  }
+};
+__name(_TransactionNotFoundException, "TransactionNotFoundException");
+var TransactionNotFoundException = _TransactionNotFoundException;
+var _NotFoundException = class _NotFoundException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var DecimalReturnType = {
+  DOUBLE_OR_LONG: "DOUBLE_OR_LONG",
+  STRING: "STRING"
+};
+var RecordsFormatType = {
+  JSON: "JSON",
+  NONE: "NONE"
+};
+var LongReturnType = {
+  LONG: "LONG",
+  STRING: "STRING"
+};
+var _UnsupportedResultException = class _UnsupportedResultException extends RDSDataServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedResultException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedResultException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedResultException.prototype);
+  }
+};
+__name(_UnsupportedResultException, "UnsupportedResultException");
+var UnsupportedResultException = _UnsupportedResultException;
+var ArrayValue;
+((ArrayValue2) => {
+  ArrayValue2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.booleanValues !== void 0)
+      return visitor.booleanValues(value.booleanValues);
+    if (value.longValues !== void 0)
+      return visitor.longValues(value.longValues);
+    if (value.doubleValues !== void 0)
+      return visitor.doubleValues(value.doubleValues);
+    if (value.stringValues !== void 0)
+      return visitor.stringValues(value.stringValues);
+    if (value.arrayValues !== void 0)
+      return visitor.arrayValues(value.arrayValues);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ArrayValue || (ArrayValue = {}));
+var Field;
+((Field2) => {
+  Field2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.isNull !== void 0)
+      return visitor.isNull(value.isNull);
+    if (value.booleanValue !== void 0)
+      return visitor.booleanValue(value.booleanValue);
+    if (value.longValue !== void 0)
+      return visitor.longValue(value.longValue);
+    if (value.doubleValue !== void 0)
+      return visitor.doubleValue(value.doubleValue);
+    if (value.stringValue !== void 0)
+      return visitor.stringValue(value.stringValue);
+    if (value.blobValue !== void 0)
+      return visitor.blobValue(value.blobValue);
+    if (value.arrayValue !== void 0)
+      return visitor.arrayValue(value.arrayValue);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Field || (Field = {}));
+var Value;
+((Value3) => {
+  Value3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.isNull !== void 0)
+      return visitor.isNull(value.isNull);
+    if (value.bitValue !== void 0)
+      return visitor.bitValue(value.bitValue);
+    if (value.bigIntValue !== void 0)
+      return visitor.bigIntValue(value.bigIntValue);
+    if (value.intValue !== void 0)
+      return visitor.intValue(value.intValue);
+    if (value.doubleValue !== void 0)
+      return visitor.doubleValue(value.doubleValue);
+    if (value.realValue !== void 0)
+      return visitor.realValue(value.realValue);
+    if (value.stringValue !== void 0)
+      return visitor.stringValue(value.stringValue);
+    if (value.blobValue !== void 0)
+      return visitor.blobValue(value.blobValue);
+    if (value.arrayValues !== void 0)
+      return visitor.arrayValues(value.arrayValues);
+    if (value.structValue !== void 0)
+      return visitor.structValue(value.structValue);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Value || (Value = {}));
+
+// src/protocols/Aws_restJson1.ts
+var se_BatchExecuteStatementCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/BatchExecute");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      database: [],
+      parameterSets: (_) => se_SqlParameterSets(_, context),
+      resourceArn: [],
+      schema: [],
+      secretArn: [],
+      sql: [],
+      transactionId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BatchExecuteStatementCommand");
+var se_BeginTransactionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/BeginTransaction");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      database: [],
+      resourceArn: [],
+      schema: [],
+      secretArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BeginTransactionCommand");
+var se_CommitTransactionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CommitTransaction");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceArn: [],
+      secretArn: [],
+      transactionId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CommitTransactionCommand");
+var se_ExecuteSqlCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ExecuteSql");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      awsSecretStoreArn: [],
+      database: [],
+      dbClusterOrInstanceArn: [],
+      schema: [],
+      sqlStatements: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ExecuteSqlCommand");
+var se_ExecuteStatementCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/Execute");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      continueAfterTimeout: [],
+      database: [],
+      formatRecordsAs: [],
+      includeResultMetadata: [],
+      parameters: (_) => se_SqlParametersList(_, context),
+      resourceArn: [],
+      resultSetOptions: (_) => (0, import_smithy_client._json)(_),
+      schema: [],
+      secretArn: [],
+      sql: [],
+      transactionId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ExecuteStatementCommand");
+var se_RollbackTransactionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/RollbackTransaction");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourceArn: [],
+      secretArn: [],
+      transactionId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_RollbackTransactionCommand");
+var de_BatchExecuteStatementCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BatchExecuteStatementCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    updateResults: (_) => de_UpdateResults(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchExecuteStatementCommand");
+var de_BatchExecuteStatementCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.rdsdata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.rdsdata#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "DatabaseErrorException":
+    case "com.amazonaws.rdsdata#DatabaseErrorException":
+      throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+    case "DatabaseNotFoundException":
+    case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+      throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+    case "DatabaseUnavailableException":
+    case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+      throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.rdsdata#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "HttpEndpointNotEnabledException":
+    case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+      throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.rdsdata#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "InvalidSecretException":
+    case "com.amazonaws.rdsdata#InvalidSecretException":
+      throw await de_InvalidSecretExceptionRes(parsedOutput, context);
+    case "SecretsErrorException":
+    case "com.amazonaws.rdsdata#SecretsErrorException":
+      throw await de_SecretsErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableError":
+    case "com.amazonaws.rdsdata#ServiceUnavailableError":
+      throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
+    case "StatementTimeoutException":
+    case "com.amazonaws.rdsdata#StatementTimeoutException":
+      throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+    case "TransactionNotFoundException":
+    case "com.amazonaws.rdsdata#TransactionNotFoundException":
+      throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchExecuteStatementCommandError");
+var de_BeginTransactionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BeginTransactionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    transactionId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BeginTransactionCommand");
+var de_BeginTransactionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.rdsdata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.rdsdata#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "DatabaseErrorException":
+    case "com.amazonaws.rdsdata#DatabaseErrorException":
+      throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+    case "DatabaseNotFoundException":
+    case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+      throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+    case "DatabaseUnavailableException":
+    case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+      throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.rdsdata#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "HttpEndpointNotEnabledException":
+    case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+      throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.rdsdata#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "InvalidSecretException":
+    case "com.amazonaws.rdsdata#InvalidSecretException":
+      throw await de_InvalidSecretExceptionRes(parsedOutput, context);
+    case "SecretsErrorException":
+    case "com.amazonaws.rdsdata#SecretsErrorException":
+      throw await de_SecretsErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableError":
+    case "com.amazonaws.rdsdata#ServiceUnavailableError":
+      throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
+    case "StatementTimeoutException":
+    case "com.amazonaws.rdsdata#StatementTimeoutException":
+      throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+    case "TransactionNotFoundException":
+    case "com.amazonaws.rdsdata#TransactionNotFoundException":
+      throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BeginTransactionCommandError");
+var de_CommitTransactionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommitTransactionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    transactionStatus: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CommitTransactionCommand");
+var de_CommitTransactionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.rdsdata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.rdsdata#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "DatabaseErrorException":
+    case "com.amazonaws.rdsdata#DatabaseErrorException":
+      throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+    case "DatabaseNotFoundException":
+    case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+      throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+    case "DatabaseUnavailableException":
+    case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+      throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.rdsdata#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "HttpEndpointNotEnabledException":
+    case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+      throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.rdsdata#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "InvalidSecretException":
+    case "com.amazonaws.rdsdata#InvalidSecretException":
+      throw await de_InvalidSecretExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.rdsdata#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "SecretsErrorException":
+    case "com.amazonaws.rdsdata#SecretsErrorException":
+      throw await de_SecretsErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableError":
+    case "com.amazonaws.rdsdata#ServiceUnavailableError":
+      throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
+    case "StatementTimeoutException":
+    case "com.amazonaws.rdsdata#StatementTimeoutException":
+      throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+    case "TransactionNotFoundException":
+    case "com.amazonaws.rdsdata#TransactionNotFoundException":
+      throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CommitTransactionCommandError");
+var de_ExecuteSqlCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ExecuteSqlCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    sqlStatementResults: (_) => de_SqlStatementResults(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ExecuteSqlCommand");
+var de_ExecuteSqlCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.rdsdata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.rdsdata#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.rdsdata#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.rdsdata#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableError":
+    case "com.amazonaws.rdsdata#ServiceUnavailableError":
+      throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ExecuteSqlCommandError");
+var de_ExecuteStatementCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ExecuteStatementCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    columnMetadata: import_smithy_client._json,
+    formattedRecords: import_smithy_client.expectString,
+    generatedFields: (_) => de_FieldList(_, context),
+    numberOfRecordsUpdated: import_smithy_client.expectLong,
+    records: (_) => de_SqlRecords(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ExecuteStatementCommand");
+var de_ExecuteStatementCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.rdsdata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.rdsdata#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "DatabaseErrorException":
+    case "com.amazonaws.rdsdata#DatabaseErrorException":
+      throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+    case "DatabaseNotFoundException":
+    case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+      throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+    case "DatabaseUnavailableException":
+    case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+      throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.rdsdata#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "HttpEndpointNotEnabledException":
+    case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+      throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.rdsdata#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "InvalidSecretException":
+    case "com.amazonaws.rdsdata#InvalidSecretException":
+      throw await de_InvalidSecretExceptionRes(parsedOutput, context);
+    case "SecretsErrorException":
+    case "com.amazonaws.rdsdata#SecretsErrorException":
+      throw await de_SecretsErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableError":
+    case "com.amazonaws.rdsdata#ServiceUnavailableError":
+      throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
+    case "StatementTimeoutException":
+    case "com.amazonaws.rdsdata#StatementTimeoutException":
+      throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+    case "TransactionNotFoundException":
+    case "com.amazonaws.rdsdata#TransactionNotFoundException":
+      throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedResultException":
+    case "com.amazonaws.rdsdata#UnsupportedResultException":
+      throw await de_UnsupportedResultExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ExecuteStatementCommandError");
+var de_RollbackTransactionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_RollbackTransactionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    transactionStatus: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_RollbackTransactionCommand");
+var de_RollbackTransactionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.rdsdata#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.rdsdata#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "DatabaseErrorException":
+    case "com.amazonaws.rdsdata#DatabaseErrorException":
+      throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+    case "DatabaseNotFoundException":
+    case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+      throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+    case "DatabaseUnavailableException":
+    case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+      throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.rdsdata#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "HttpEndpointNotEnabledException":
+    case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+      throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.rdsdata#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "InvalidSecretException":
+    case "com.amazonaws.rdsdata#InvalidSecretException":
+      throw await de_InvalidSecretExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.rdsdata#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "SecretsErrorException":
+    case "com.amazonaws.rdsdata#SecretsErrorException":
+      throw await de_SecretsErrorExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableError":
+    case "com.amazonaws.rdsdata#ServiceUnavailableError":
+      throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
+    case "StatementTimeoutException":
+    case "com.amazonaws.rdsdata#StatementTimeoutException":
+      throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+    case "TransactionNotFoundException":
+    case "com.amazonaws.rdsdata#TransactionNotFoundException":
+      throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RollbackTransactionCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(RDSDataServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new BadRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadRequestExceptionRes");
+var de_DatabaseErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new DatabaseErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_DatabaseErrorExceptionRes");
+var de_DatabaseNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new DatabaseNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_DatabaseNotFoundExceptionRes");
+var de_DatabaseUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {});
+  Object.assign(contents, doc);
+  const exception = new DatabaseUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_DatabaseUnavailableExceptionRes");
+var de_ForbiddenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ForbiddenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ForbiddenExceptionRes");
+var de_HttpEndpointNotEnabledExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new HttpEndpointNotEnabledException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_HttpEndpointNotEnabledExceptionRes");
+var de_InternalServerErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {});
+  Object.assign(contents, doc);
+  const exception = new InternalServerErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerErrorExceptionRes");
+var de_InvalidSecretExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InvalidSecretException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidSecretExceptionRes");
+var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new NotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NotFoundExceptionRes");
+var de_SecretsErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new SecretsErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_SecretsErrorExceptionRes");
+var de_ServiceUnavailableErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {});
+  Object.assign(contents, doc);
+  const exception = new ServiceUnavailableError({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceUnavailableErrorRes");
+var de_StatementTimeoutExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    dbConnectionId: import_smithy_client.expectLong,
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new StatementTimeoutException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_StatementTimeoutExceptionRes");
+var de_TransactionNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TransactionNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TransactionNotFoundExceptionRes");
+var de_UnsupportedResultExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new UnsupportedResultException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_UnsupportedResultExceptionRes");
+var se_ArrayOfArray = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_ArrayValue(entry, context);
+  });
+}, "se_ArrayOfArray");
+var se_ArrayValue = /* @__PURE__ */ __name((input, context) => {
+  return ArrayValue.visit(input, {
+    arrayValues: (value) => ({ arrayValues: se_ArrayOfArray(value, context) }),
+    booleanValues: (value) => ({ booleanValues: (0, import_smithy_client._json)(value) }),
+    doubleValues: (value) => ({ doubleValues: se_DoubleArray(value, context) }),
+    longValues: (value) => ({ longValues: (0, import_smithy_client._json)(value) }),
+    stringValues: (value) => ({ stringValues: (0, import_smithy_client._json)(value) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_ArrayValue");
+var se_DoubleArray = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.serializeFloat)(entry);
+  });
+}, "se_DoubleArray");
+var se_Field = /* @__PURE__ */ __name((input, context) => {
+  return Field.visit(input, {
+    arrayValue: (value) => ({ arrayValue: se_ArrayValue(value, context) }),
+    blobValue: (value) => ({ blobValue: context.base64Encoder(value) }),
+    booleanValue: (value) => ({ booleanValue: value }),
+    doubleValue: (value) => ({ doubleValue: (0, import_smithy_client.serializeFloat)(value) }),
+    isNull: (value) => ({ isNull: value }),
+    longValue: (value) => ({ longValue: value }),
+    stringValue: (value) => ({ stringValue: value }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_Field");
+var se_SqlParameter = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    name: [],
+    typeHint: [],
+    value: (_) => se_Field(_, context)
+  });
+}, "se_SqlParameter");
+var se_SqlParameterSets = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_SqlParametersList(entry, context);
+  });
+}, "se_SqlParameterSets");
+var se_SqlParametersList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_SqlParameter(entry, context);
+  });
+}, "se_SqlParametersList");
+var de_ArrayOfArray = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ArrayValue((0, import_core.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_ArrayOfArray");
+var de_ArrayValue = /* @__PURE__ */ __name((output, context) => {
+  if (output.arrayValues != null) {
+    return {
+      arrayValues: de_ArrayOfArray(output.arrayValues, context)
+    };
+  }
+  if (output.booleanValues != null) {
+    return {
+      booleanValues: (0, import_smithy_client._json)(output.booleanValues)
+    };
+  }
+  if (output.doubleValues != null) {
+    return {
+      doubleValues: de_DoubleArray(output.doubleValues, context)
+    };
+  }
+  if (output.longValues != null) {
+    return {
+      longValues: (0, import_smithy_client._json)(output.longValues)
+    };
+  }
+  if (output.stringValues != null) {
+    return {
+      stringValues: (0, import_smithy_client._json)(output.stringValues)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_ArrayValue");
+var de_ArrayValueList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Value((0, import_core.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_ArrayValueList");
+var de_DoubleArray = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.limitedParseDouble)(entry);
+  });
+  return retVal;
+}, "de_DoubleArray");
+var de_Field = /* @__PURE__ */ __name((output, context) => {
+  if (output.arrayValue != null) {
+    return {
+      arrayValue: de_ArrayValue((0, import_core.awsExpectUnion)(output.arrayValue), context)
+    };
+  }
+  if (output.blobValue != null) {
+    return {
+      blobValue: context.base64Decoder(output.blobValue)
+    };
+  }
+  if ((0, import_smithy_client.expectBoolean)(output.booleanValue) !== void 0) {
+    return { booleanValue: (0, import_smithy_client.expectBoolean)(output.booleanValue) };
+  }
+  if ((0, import_smithy_client.limitedParseDouble)(output.doubleValue) !== void 0) {
+    return { doubleValue: (0, import_smithy_client.limitedParseDouble)(output.doubleValue) };
+  }
+  if ((0, import_smithy_client.expectBoolean)(output.isNull) !== void 0) {
+    return { isNull: (0, import_smithy_client.expectBoolean)(output.isNull) };
+  }
+  if ((0, import_smithy_client.expectLong)(output.longValue) !== void 0) {
+    return { longValue: (0, import_smithy_client.expectLong)(output.longValue) };
+  }
+  if ((0, import_smithy_client.expectString)(output.stringValue) !== void 0) {
+    return { stringValue: (0, import_smithy_client.expectString)(output.stringValue) };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_Field");
+var de_FieldList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Field((0, import_core.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_FieldList");
+var de__Record = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    values: (_) => de_Row(_, context)
+  });
+}, "de__Record");
+var de_Records = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de__Record(entry, context);
+  });
+  return retVal;
+}, "de_Records");
+var de_ResultFrame = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    records: (_) => de_Records(_, context),
+    resultSetMetadata: import_smithy_client._json
+  });
+}, "de_ResultFrame");
+var de_Row = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Value((0, import_core.awsExpectUnion)(entry), context);
+  });
+  return retVal;
+}, "de_Row");
+var de_SqlRecords = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FieldList(entry, context);
+  });
+  return retVal;
+}, "de_SqlRecords");
+var de_SqlStatementResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    numberOfRecordsUpdated: import_smithy_client.expectLong,
+    resultFrame: (_) => de_ResultFrame(_, context)
+  });
+}, "de_SqlStatementResult");
+var de_SqlStatementResults = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SqlStatementResult(entry, context);
+  });
+  return retVal;
+}, "de_SqlStatementResults");
+var de_StructValue = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    attributes: (_) => de_ArrayValueList(_, context)
+  });
+}, "de_StructValue");
+var de_UpdateResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    generatedFields: (_) => de_FieldList(_, context)
+  });
+}, "de_UpdateResult");
+var de_UpdateResults = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_UpdateResult(entry, context);
+  });
+  return retVal;
+}, "de_UpdateResults");
+var de_Value = /* @__PURE__ */ __name((output, context) => {
+  if (output.arrayValues != null) {
+    return {
+      arrayValues: de_ArrayValueList(output.arrayValues, context)
+    };
+  }
+  if ((0, import_smithy_client.expectLong)(output.bigIntValue) !== void 0) {
+    return { bigIntValue: (0, import_smithy_client.expectLong)(output.bigIntValue) };
+  }
+  if ((0, import_smithy_client.expectBoolean)(output.bitValue) !== void 0) {
+    return { bitValue: (0, import_smithy_client.expectBoolean)(output.bitValue) };
+  }
+  if (output.blobValue != null) {
+    return {
+      blobValue: context.base64Decoder(output.blobValue)
+    };
+  }
+  if ((0, import_smithy_client.limitedParseDouble)(output.doubleValue) !== void 0) {
+    return { doubleValue: (0, import_smithy_client.limitedParseDouble)(output.doubleValue) };
+  }
+  if ((0, import_smithy_client.expectInt32)(output.intValue) !== void 0) {
+    return { intValue: (0, import_smithy_client.expectInt32)(output.intValue) };
+  }
+  if ((0, import_smithy_client.expectBoolean)(output.isNull) !== void 0) {
+    return { isNull: (0, import_smithy_client.expectBoolean)(output.isNull) };
+  }
+  if ((0, import_smithy_client.limitedParseFloat32)(output.realValue) !== void 0) {
+    return { realValue: (0, import_smithy_client.limitedParseFloat32)(output.realValue) };
+  }
+  if ((0, import_smithy_client.expectString)(output.stringValue) !== void 0) {
+    return { stringValue: (0, import_smithy_client.expectString)(output.stringValue) };
+  }
+  if (output.structValue != null) {
+    return {
+      structValue: de_StructValue(output.structValue, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_Value");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/BatchExecuteStatementCommand.ts
+var _BatchExecuteStatementCommand = class _BatchExecuteStatementCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RdsDataService", "BatchExecuteStatement", {}).n("RDSDataClient", "BatchExecuteStatementCommand").f(void 0, void 0).ser(se_BatchExecuteStatementCommand).de(de_BatchExecuteStatementCommand).build() {
+};
+__name(_BatchExecuteStatementCommand, "BatchExecuteStatementCommand");
+var BatchExecuteStatementCommand = _BatchExecuteStatementCommand;
+
+// src/commands/BeginTransactionCommand.ts
+
+
+
+
+var _BeginTransactionCommand = class _BeginTransactionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RdsDataService", "BeginTransaction", {}).n("RDSDataClient", "BeginTransactionCommand").f(void 0, void 0).ser(se_BeginTransactionCommand).de(de_BeginTransactionCommand).build() {
+};
+__name(_BeginTransactionCommand, "BeginTransactionCommand");
+var BeginTransactionCommand = _BeginTransactionCommand;
+
+// src/commands/CommitTransactionCommand.ts
+
+
+
+
+var _CommitTransactionCommand = class _CommitTransactionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RdsDataService", "CommitTransaction", {}).n("RDSDataClient", "CommitTransactionCommand").f(void 0, void 0).ser(se_CommitTransactionCommand).de(de_CommitTransactionCommand).build() {
+};
+__name(_CommitTransactionCommand, "CommitTransactionCommand");
+var CommitTransactionCommand = _CommitTransactionCommand;
+
+// src/commands/ExecuteSqlCommand.ts
+
+
+
+
+var _ExecuteSqlCommand = class _ExecuteSqlCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RdsDataService", "ExecuteSql", {}).n("RDSDataClient", "ExecuteSqlCommand").f(void 0, void 0).ser(se_ExecuteSqlCommand).de(de_ExecuteSqlCommand).build() {
+};
+__name(_ExecuteSqlCommand, "ExecuteSqlCommand");
+var ExecuteSqlCommand = _ExecuteSqlCommand;
+
+// src/commands/ExecuteStatementCommand.ts
+
+
+
+
+var _ExecuteStatementCommand = class _ExecuteStatementCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RdsDataService", "ExecuteStatement", {}).n("RDSDataClient", "ExecuteStatementCommand").f(void 0, void 0).ser(se_ExecuteStatementCommand).de(de_ExecuteStatementCommand).build() {
+};
+__name(_ExecuteStatementCommand, "ExecuteStatementCommand");
+var ExecuteStatementCommand = _ExecuteStatementCommand;
+
+// src/commands/RollbackTransactionCommand.ts
+
+
+
+
+var _RollbackTransactionCommand = class _RollbackTransactionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("RdsDataService", "RollbackTransaction", {}).n("RDSDataClient", "RollbackTransactionCommand").f(void 0, void 0).ser(se_RollbackTransactionCommand).de(de_RollbackTransactionCommand).build() {
+};
+__name(_RollbackTransactionCommand, "RollbackTransactionCommand");
+var RollbackTransactionCommand = _RollbackTransactionCommand;
+
+// src/RDSData.ts
+var commands = {
+  BatchExecuteStatementCommand,
+  BeginTransactionCommand,
+  CommitTransactionCommand,
+  ExecuteSqlCommand,
+  ExecuteStatementCommand,
+  RollbackTransactionCommand
+};
+var _RDSData = class _RDSData extends RDSDataClient {
+};
+__name(_RDSData, "RDSData");
+var RDSData = _RDSData;
+(0, import_smithy_client.createAggregatedClient)(commands, RDSData);
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessDeniedException,
+  ArrayValue,
+  BadRequestException,
+  BatchExecuteStatementCommand,
+  BeginTransactionCommand,
+  CommitTransactionCommand,
+  DatabaseErrorException,
+  DatabaseNotFoundException,
+  DatabaseUnavailableException,
+  DecimalReturnType,
+  ExecuteSqlCommand,
+  ExecuteStatementCommand,
+  Field,
+  ForbiddenException,
+  HttpEndpointNotEnabledException,
+  InternalServerErrorException,
+  InvalidSecretException,
+  LongReturnType,
+  NotFoundException,
+  RDSData,
+  RDSDataClient,
+  RDSDataServiceException,
+  RecordsFormatType,
+  RollbackTransactionCommand,
+  SecretsErrorException,
+  ServiceUnavailableError,
+  StatementTimeoutException,
+  TransactionNotFoundException,
+  TypeHint,
+  UnsupportedResultException,
+  Value,
+  __Client
+});