serverless-spy/node_modules/@aws-sdk/client-dynamodb/dist-cjs/index.js

CDK-based library for writing elegant integration tests on AWS serverless architecture and an additional web console to monitor events in real time.

"use strict";
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, {
  ApproximateCreationDateTimePrecision: () => ApproximateCreationDateTimePrecision,
  AttributeAction: () => AttributeAction,
  AttributeValue: () => AttributeValue,
  BackupInUseException: () => BackupInUseException,
  BackupNotFoundException: () => BackupNotFoundException,
  BackupStatus: () => BackupStatus,
  BackupType: () => BackupType,
  BackupTypeFilter: () => BackupTypeFilter,
  BatchExecuteStatementCommand: () => BatchExecuteStatementCommand,
  BatchGetItemCommand: () => BatchGetItemCommand,
  BatchStatementErrorCodeEnum: () => BatchStatementErrorCodeEnum,
  BatchWriteItemCommand: () => BatchWriteItemCommand,
  BillingMode: () => BillingMode,
  ComparisonOperator: () => ComparisonOperator,
  ConditionalCheckFailedException: () => ConditionalCheckFailedException,
  ConditionalOperator: () => ConditionalOperator,
  ContinuousBackupsStatus: () => ContinuousBackupsStatus,
  ContinuousBackupsUnavailableException: () => ContinuousBackupsUnavailableException,
  ContributorInsightsAction: () => ContributorInsightsAction,
  ContributorInsightsStatus: () => ContributorInsightsStatus,
  CreateBackupCommand: () => CreateBackupCommand,
  CreateGlobalTableCommand: () => CreateGlobalTableCommand,
  CreateTableCommand: () => CreateTableCommand,
  DeleteBackupCommand: () => DeleteBackupCommand,
  DeleteItemCommand: () => DeleteItemCommand,
  DeleteResourcePolicyCommand: () => DeleteResourcePolicyCommand,
  DeleteTableCommand: () => DeleteTableCommand,
  DescribeBackupCommand: () => DescribeBackupCommand,
  DescribeContinuousBackupsCommand: () => DescribeContinuousBackupsCommand,
  DescribeContributorInsightsCommand: () => DescribeContributorInsightsCommand,
  DescribeEndpointsCommand: () => DescribeEndpointsCommand,
  DescribeExportCommand: () => DescribeExportCommand,
  DescribeGlobalTableCommand: () => DescribeGlobalTableCommand,
  DescribeGlobalTableSettingsCommand: () => DescribeGlobalTableSettingsCommand,
  DescribeImportCommand: () => DescribeImportCommand,
  DescribeKinesisStreamingDestinationCommand: () => DescribeKinesisStreamingDestinationCommand,
  DescribeLimitsCommand: () => DescribeLimitsCommand,
  DescribeTableCommand: () => DescribeTableCommand,
  DescribeTableReplicaAutoScalingCommand: () => DescribeTableReplicaAutoScalingCommand,
  DescribeTimeToLiveCommand: () => DescribeTimeToLiveCommand,
  DestinationStatus: () => DestinationStatus,
  DisableKinesisStreamingDestinationCommand: () => DisableKinesisStreamingDestinationCommand,
  DuplicateItemException: () => DuplicateItemException,
  DynamoDB: () => DynamoDB,
  DynamoDBClient: () => DynamoDBClient,
  DynamoDBServiceException: () => DynamoDBServiceException,
  EnableKinesisStreamingDestinationCommand: () => EnableKinesisStreamingDestinationCommand,
  ExecuteStatementCommand: () => ExecuteStatementCommand,
  ExecuteTransactionCommand: () => ExecuteTransactionCommand,
  ExportConflictException: () => ExportConflictException,
  ExportFormat: () => ExportFormat,
  ExportNotFoundException: () => ExportNotFoundException,
  ExportStatus: () => ExportStatus,
  ExportTableToPointInTimeCommand: () => ExportTableToPointInTimeCommand,
  ExportType: () => ExportType,
  ExportViewType: () => ExportViewType,
  GetItemCommand: () => GetItemCommand,
  GetResourcePolicyCommand: () => GetResourcePolicyCommand,
  GlobalTableAlreadyExistsException: () => GlobalTableAlreadyExistsException,
  GlobalTableNotFoundException: () => GlobalTableNotFoundException,
  GlobalTableStatus: () => GlobalTableStatus,
  IdempotentParameterMismatchException: () => IdempotentParameterMismatchException,
  ImportConflictException: () => ImportConflictException,
  ImportNotFoundException: () => ImportNotFoundException,
  ImportStatus: () => ImportStatus,
  ImportTableCommand: () => ImportTableCommand,
  IndexNotFoundException: () => IndexNotFoundException,
  IndexStatus: () => IndexStatus,
  InputCompressionType: () => InputCompressionType,
  InputFormat: () => InputFormat,
  InternalServerError: () => InternalServerError,
  InvalidEndpointException: () => InvalidEndpointException,
  InvalidExportTimeException: () => InvalidExportTimeException,
  InvalidRestoreTimeException: () => InvalidRestoreTimeException,
  ItemCollectionSizeLimitExceededException: () => ItemCollectionSizeLimitExceededException,
  KeyType: () => KeyType,
  LimitExceededException: () => LimitExceededException,
  ListBackupsCommand: () => ListBackupsCommand,
  ListContributorInsightsCommand: () => ListContributorInsightsCommand,
  ListExportsCommand: () => ListExportsCommand,
  ListGlobalTablesCommand: () => ListGlobalTablesCommand,
  ListImportsCommand: () => ListImportsCommand,
  ListTablesCommand: () => ListTablesCommand,
  ListTagsOfResourceCommand: () => ListTagsOfResourceCommand,
  MultiRegionConsistency: () => MultiRegionConsistency,
  PointInTimeRecoveryStatus: () => PointInTimeRecoveryStatus,
  PointInTimeRecoveryUnavailableException: () => PointInTimeRecoveryUnavailableException,
  PolicyNotFoundException: () => PolicyNotFoundException,
  ProjectionType: () => ProjectionType,
  ProvisionedThroughputExceededException: () => ProvisionedThroughputExceededException,
  PutItemCommand: () => PutItemCommand,
  PutResourcePolicyCommand: () => PutResourcePolicyCommand,
  QueryCommand: () => QueryCommand,
  ReplicaAlreadyExistsException: () => ReplicaAlreadyExistsException,
  ReplicaNotFoundException: () => ReplicaNotFoundException,
  ReplicaStatus: () => ReplicaStatus,
  ReplicatedWriteConflictException: () => ReplicatedWriteConflictException,
  RequestLimitExceeded: () => RequestLimitExceeded,
  ResourceInUseException: () => ResourceInUseException,
  ResourceNotFoundException: () => ResourceNotFoundException,
  RestoreTableFromBackupCommand: () => RestoreTableFromBackupCommand,
  RestoreTableToPointInTimeCommand: () => RestoreTableToPointInTimeCommand,
  ReturnConsumedCapacity: () => ReturnConsumedCapacity,
  ReturnItemCollectionMetrics: () => ReturnItemCollectionMetrics,
  ReturnValue: () => ReturnValue,
  ReturnValuesOnConditionCheckFailure: () => ReturnValuesOnConditionCheckFailure,
  S3SseAlgorithm: () => S3SseAlgorithm,
  SSEStatus: () => SSEStatus,
  SSEType: () => SSEType,
  ScalarAttributeType: () => ScalarAttributeType,
  ScanCommand: () => ScanCommand,
  Select: () => Select,
  StreamViewType: () => StreamViewType,
  TableAlreadyExistsException: () => TableAlreadyExistsException,
  TableClass: () => TableClass,
  TableInUseException: () => TableInUseException,
  TableNotFoundException: () => TableNotFoundException,
  TableStatus: () => TableStatus,
  TagResourceCommand: () => TagResourceCommand,
  TimeToLiveStatus: () => TimeToLiveStatus,
  TransactGetItemsCommand: () => TransactGetItemsCommand,
  TransactWriteItemsCommand: () => TransactWriteItemsCommand,
  TransactionCanceledException: () => TransactionCanceledException,
  TransactionConflictException: () => TransactionConflictException,
  TransactionInProgressException: () => TransactionInProgressException,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateContinuousBackupsCommand: () => UpdateContinuousBackupsCommand,
  UpdateContributorInsightsCommand: () => UpdateContributorInsightsCommand,
  UpdateGlobalTableCommand: () => UpdateGlobalTableCommand,
  UpdateGlobalTableSettingsCommand: () => UpdateGlobalTableSettingsCommand,
  UpdateItemCommand: () => UpdateItemCommand,
  UpdateKinesisStreamingDestinationCommand: () => UpdateKinesisStreamingDestinationCommand,
  UpdateTableCommand: () => UpdateTableCommand,
  UpdateTableReplicaAutoScalingCommand: () => UpdateTableReplicaAutoScalingCommand,
  UpdateTimeToLiveCommand: () => UpdateTimeToLiveCommand,
  __Client: () => import_smithy_client.Client,
  paginateListContributorInsights: () => paginateListContributorInsights,
  paginateListExports: () => paginateListExports,
  paginateListImports: () => paginateListImports,
  paginateListTables: () => paginateListTables,
  paginateQuery: () => paginateQuery,
  paginateScan: () => paginateScan,
  waitForTableExists: () => waitForTableExists,
  waitForTableNotExists: () => waitForTableNotExists,
  waitUntilTableExists: () => waitUntilTableExists,
  waitUntilTableNotExists: () => waitUntilTableNotExists
});
module.exports = __toCommonJS(src_exports);

// src/DynamoDBClient.ts
var import_account_id_endpoint = require("@aws-sdk/core/account-id-endpoint");
var import_middleware_endpoint_discovery = require("@aws-sdk/middleware-endpoint-discovery");
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_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core2 = require("@smithy/core");
var import_middleware_content_length = require("@smithy/middleware-content-length");

var import_middleware_retry = require("@smithy/middleware-retry");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/commands/DescribeEndpointsCommand.ts
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_serde = require("@smithy/middleware-serde");


// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "dynamodb"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  AccountId: { type: "builtInParams", name: "accountId" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
  AccountIdEndpointMode: { type: "builtInParams", name: "accountIdEndpointMode" }
};

// src/protocols/Aws_json1_0.ts
var import_core = require("@aws-sdk/core");
var import_protocol_http = require("@smithy/protocol-http");

var import_uuid = require("uuid");

// src/models/DynamoDBServiceException.ts
var import_smithy_client = require("@smithy/smithy-client");
var _DynamoDBServiceException = class _DynamoDBServiceException extends import_smithy_client.ServiceException {
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _DynamoDBServiceException.prototype);
  }
};
__name(_DynamoDBServiceException, "DynamoDBServiceException");
var DynamoDBServiceException = _DynamoDBServiceException;

// src/models/models_0.ts
var ApproximateCreationDateTimePrecision = {
  MICROSECOND: "MICROSECOND",
  MILLISECOND: "MILLISECOND"
};
var AttributeAction = {
  ADD: "ADD",
  DELETE: "DELETE",
  PUT: "PUT"
};
var ScalarAttributeType = {
  B: "B",
  N: "N",
  S: "S"
};
var BackupStatus = {
  AVAILABLE: "AVAILABLE",
  CREATING: "CREATING",
  DELETED: "DELETED"
};
var BackupType = {
  AWS_BACKUP: "AWS_BACKUP",
  SYSTEM: "SYSTEM",
  USER: "USER"
};
var BillingMode = {
  PAY_PER_REQUEST: "PAY_PER_REQUEST",
  PROVISIONED: "PROVISIONED"
};
var KeyType = {
  HASH: "HASH",
  RANGE: "RANGE"
};
var ProjectionType = {
  ALL: "ALL",
  INCLUDE: "INCLUDE",
  KEYS_ONLY: "KEYS_ONLY"
};
var SSEType = {
  AES256: "AES256",
  KMS: "KMS"
};
var SSEStatus = {
  DISABLED: "DISABLED",
  DISABLING: "DISABLING",
  ENABLED: "ENABLED",
  ENABLING: "ENABLING",
  UPDATING: "UPDATING"
};
var StreamViewType = {
  KEYS_ONLY: "KEYS_ONLY",
  NEW_AND_OLD_IMAGES: "NEW_AND_OLD_IMAGES",
  NEW_IMAGE: "NEW_IMAGE",
  OLD_IMAGE: "OLD_IMAGE"
};
var TimeToLiveStatus = {
  DISABLED: "DISABLED",
  DISABLING: "DISABLING",
  ENABLED: "ENABLED",
  ENABLING: "ENABLING"
};
var _BackupInUseException = class _BackupInUseException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "BackupInUseException",
      $fault: "client",
      ...opts
    });
    this.name = "BackupInUseException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _BackupInUseException.prototype);
  }
};
__name(_BackupInUseException, "BackupInUseException");
var BackupInUseException = _BackupInUseException;
var _BackupNotFoundException = class _BackupNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "BackupNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "BackupNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _BackupNotFoundException.prototype);
  }
};
__name(_BackupNotFoundException, "BackupNotFoundException");
var BackupNotFoundException = _BackupNotFoundException;
var BackupTypeFilter = {
  ALL: "ALL",
  AWS_BACKUP: "AWS_BACKUP",
  SYSTEM: "SYSTEM",
  USER: "USER"
};
var ReturnConsumedCapacity = {
  INDEXES: "INDEXES",
  NONE: "NONE",
  TOTAL: "TOTAL"
};
var ReturnValuesOnConditionCheckFailure = {
  ALL_OLD: "ALL_OLD",
  NONE: "NONE"
};
var BatchStatementErrorCodeEnum = {
  AccessDenied: "AccessDenied",
  ConditionalCheckFailed: "ConditionalCheckFailed",
  DuplicateItem: "DuplicateItem",
  InternalServerError: "InternalServerError",
  ItemCollectionSizeLimitExceeded: "ItemCollectionSizeLimitExceeded",
  ProvisionedThroughputExceeded: "ProvisionedThroughputExceeded",
  RequestLimitExceeded: "RequestLimitExceeded",
  ResourceNotFound: "ResourceNotFound",
  ThrottlingError: "ThrottlingError",
  TransactionConflict: "TransactionConflict",
  ValidationError: "ValidationError"
};
var _InternalServerError = class _InternalServerError extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InternalServerError",
      $fault: "server",
      ...opts
    });
    this.name = "InternalServerError";
    this.$fault = "server";
    Object.setPrototypeOf(this, _InternalServerError.prototype);
  }
};
__name(_InternalServerError, "InternalServerError");
var InternalServerError = _InternalServerError;
var _RequestLimitExceeded = class _RequestLimitExceeded extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "RequestLimitExceeded",
      $fault: "client",
      ...opts
    });
    this.name = "RequestLimitExceeded";
    this.$fault = "client";
    Object.setPrototypeOf(this, _RequestLimitExceeded.prototype);
  }
};
__name(_RequestLimitExceeded, "RequestLimitExceeded");
var RequestLimitExceeded = _RequestLimitExceeded;
var _InvalidEndpointException = class _InvalidEndpointException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidEndpointException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidEndpointException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidEndpointException.prototype);
    this.Message = opts.Message;
  }
};
__name(_InvalidEndpointException, "InvalidEndpointException");
var InvalidEndpointException = _InvalidEndpointException;
var _ProvisionedThroughputExceededException = class _ProvisionedThroughputExceededException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ProvisionedThroughputExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "ProvisionedThroughputExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ProvisionedThroughputExceededException.prototype);
  }
};
__name(_ProvisionedThroughputExceededException, "ProvisionedThroughputExceededException");
var ProvisionedThroughputExceededException = _ProvisionedThroughputExceededException;
var _ResourceNotFoundException = class _ResourceNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
  }
};
__name(_ResourceNotFoundException, "ResourceNotFoundException");
var ResourceNotFoundException = _ResourceNotFoundException;
var ReturnItemCollectionMetrics = {
  NONE: "NONE",
  SIZE: "SIZE"
};
var _ItemCollectionSizeLimitExceededException = class _ItemCollectionSizeLimitExceededException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ItemCollectionSizeLimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "ItemCollectionSizeLimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ItemCollectionSizeLimitExceededException.prototype);
  }
};
__name(_ItemCollectionSizeLimitExceededException, "ItemCollectionSizeLimitExceededException");
var ItemCollectionSizeLimitExceededException = _ItemCollectionSizeLimitExceededException;
var ComparisonOperator = {
  BEGINS_WITH: "BEGINS_WITH",
  BETWEEN: "BETWEEN",
  CONTAINS: "CONTAINS",
  EQ: "EQ",
  GE: "GE",
  GT: "GT",
  IN: "IN",
  LE: "LE",
  LT: "LT",
  NE: "NE",
  NOT_CONTAINS: "NOT_CONTAINS",
  NOT_NULL: "NOT_NULL",
  NULL: "NULL"
};
var ConditionalOperator = {
  AND: "AND",
  OR: "OR"
};
var ContinuousBackupsStatus = {
  DISABLED: "DISABLED",
  ENABLED: "ENABLED"
};
var PointInTimeRecoveryStatus = {
  DISABLED: "DISABLED",
  ENABLED: "ENABLED"
};
var _ContinuousBackupsUnavailableException = class _ContinuousBackupsUnavailableException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ContinuousBackupsUnavailableException",
      $fault: "client",
      ...opts
    });
    this.name = "ContinuousBackupsUnavailableException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ContinuousBackupsUnavailableException.prototype);
  }
};
__name(_ContinuousBackupsUnavailableException, "ContinuousBackupsUnavailableException");
var ContinuousBackupsUnavailableException = _ContinuousBackupsUnavailableException;
var ContributorInsightsAction = {
  DISABLE: "DISABLE",
  ENABLE: "ENABLE"
};
var ContributorInsightsStatus = {
  DISABLED: "DISABLED",
  DISABLING: "DISABLING",
  ENABLED: "ENABLED",
  ENABLING: "ENABLING",
  FAILED: "FAILED"
};
var _LimitExceededException = class _LimitExceededException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "LimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _LimitExceededException.prototype);
  }
};
__name(_LimitExceededException, "LimitExceededException");
var LimitExceededException = _LimitExceededException;
var _TableInUseException = class _TableInUseException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TableInUseException",
      $fault: "client",
      ...opts
    });
    this.name = "TableInUseException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TableInUseException.prototype);
  }
};
__name(_TableInUseException, "TableInUseException");
var TableInUseException = _TableInUseException;
var _TableNotFoundException = class _TableNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TableNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "TableNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TableNotFoundException.prototype);
  }
};
__name(_TableNotFoundException, "TableNotFoundException");
var TableNotFoundException = _TableNotFoundException;
var GlobalTableStatus = {
  ACTIVE: "ACTIVE",
  CREATING: "CREATING",
  DELETING: "DELETING",
  UPDATING: "UPDATING"
};
var IndexStatus = {
  ACTIVE: "ACTIVE",
  CREATING: "CREATING",
  DELETING: "DELETING",
  UPDATING: "UPDATING"
};
var ReplicaStatus = {
  ACTIVE: "ACTIVE",
  CREATING: "CREATING",
  CREATION_FAILED: "CREATION_FAILED",
  DELETING: "DELETING",
  INACCESSIBLE_ENCRYPTION_CREDENTIALS: "INACCESSIBLE_ENCRYPTION_CREDENTIALS",
  REGION_DISABLED: "REGION_DISABLED",
  UPDATING: "UPDATING"
};
var TableClass = {
  STANDARD: "STANDARD",
  STANDARD_INFREQUENT_ACCESS: "STANDARD_INFREQUENT_ACCESS"
};
var TableStatus = {
  ACTIVE: "ACTIVE",
  ARCHIVED: "ARCHIVED",
  ARCHIVING: "ARCHIVING",
  CREATING: "CREATING",
  DELETING: "DELETING",
  INACCESSIBLE_ENCRYPTION_CREDENTIALS: "INACCESSIBLE_ENCRYPTION_CREDENTIALS",
  UPDATING: "UPDATING"
};
var _GlobalTableAlreadyExistsException = class _GlobalTableAlreadyExistsException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "GlobalTableAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "GlobalTableAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _GlobalTableAlreadyExistsException.prototype);
  }
};
__name(_GlobalTableAlreadyExistsException, "GlobalTableAlreadyExistsException");
var GlobalTableAlreadyExistsException = _GlobalTableAlreadyExistsException;
var MultiRegionConsistency = {
  EVENTUAL: "EVENTUAL",
  STRONG: "STRONG"
};
var _ResourceInUseException = class _ResourceInUseException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceInUseException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceInUseException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
  }
};
__name(_ResourceInUseException, "ResourceInUseException");
var ResourceInUseException = _ResourceInUseException;
var ReturnValue = {
  ALL_NEW: "ALL_NEW",
  ALL_OLD: "ALL_OLD",
  NONE: "NONE",
  UPDATED_NEW: "UPDATED_NEW",
  UPDATED_OLD: "UPDATED_OLD"
};
var _ReplicatedWriteConflictException = class _ReplicatedWriteConflictException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ReplicatedWriteConflictException",
      $fault: "client",
      ...opts
    });
    this.name = "ReplicatedWriteConflictException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ReplicatedWriteConflictException.prototype);
  }
};
__name(_ReplicatedWriteConflictException, "ReplicatedWriteConflictException");
var ReplicatedWriteConflictException = _ReplicatedWriteConflictException;
var _TransactionConflictException = class _TransactionConflictException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TransactionConflictException",
      $fault: "client",
      ...opts
    });
    this.name = "TransactionConflictException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TransactionConflictException.prototype);
  }
};
__name(_TransactionConflictException, "TransactionConflictException");
var TransactionConflictException = _TransactionConflictException;
var _PolicyNotFoundException = class _PolicyNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PolicyNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "PolicyNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PolicyNotFoundException.prototype);
  }
};
__name(_PolicyNotFoundException, "PolicyNotFoundException");
var PolicyNotFoundException = _PolicyNotFoundException;
var ExportFormat = {
  DYNAMODB_JSON: "DYNAMODB_JSON",
  ION: "ION"
};
var ExportStatus = {
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS"
};
var ExportType = {
  FULL_EXPORT: "FULL_EXPORT",
  INCREMENTAL_EXPORT: "INCREMENTAL_EXPORT"
};
var ExportViewType = {
  NEW_AND_OLD_IMAGES: "NEW_AND_OLD_IMAGES",
  NEW_IMAGE: "NEW_IMAGE"
};
var S3SseAlgorithm = {
  AES256: "AES256",
  KMS: "KMS"
};
var _ExportNotFoundException = class _ExportNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ExportNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ExportNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ExportNotFoundException.prototype);
  }
};
__name(_ExportNotFoundException, "ExportNotFoundException");
var ExportNotFoundException = _ExportNotFoundException;
var _GlobalTableNotFoundException = class _GlobalTableNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "GlobalTableNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "GlobalTableNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _GlobalTableNotFoundException.prototype);
  }
};
__name(_GlobalTableNotFoundException, "GlobalTableNotFoundException");
var GlobalTableNotFoundException = _GlobalTableNotFoundException;
var ImportStatus = {
  CANCELLED: "CANCELLED",
  CANCELLING: "CANCELLING",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS"
};
var InputCompressionType = {
  GZIP: "GZIP",
  NONE: "NONE",
  ZSTD: "ZSTD"
};
var InputFormat = {
  CSV: "CSV",
  DYNAMODB_JSON: "DYNAMODB_JSON",
  ION: "ION"
};
var _ImportNotFoundException = class _ImportNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ImportNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ImportNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ImportNotFoundException.prototype);
  }
};
__name(_ImportNotFoundException, "ImportNotFoundException");
var ImportNotFoundException = _ImportNotFoundException;
var DestinationStatus = {
  ACTIVE: "ACTIVE",
  DISABLED: "DISABLED",
  DISABLING: "DISABLING",
  ENABLE_FAILED: "ENABLE_FAILED",
  ENABLING: "ENABLING",
  UPDATING: "UPDATING"
};
var _DuplicateItemException = class _DuplicateItemException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DuplicateItemException",
      $fault: "client",
      ...opts
    });
    this.name = "DuplicateItemException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _DuplicateItemException.prototype);
  }
};
__name(_DuplicateItemException, "DuplicateItemException");
var DuplicateItemException = _DuplicateItemException;
var _IdempotentParameterMismatchException = class _IdempotentParameterMismatchException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "IdempotentParameterMismatchException",
      $fault: "client",
      ...opts
    });
    this.name = "IdempotentParameterMismatchException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _IdempotentParameterMismatchException.prototype);
    this.Message = opts.Message;
  }
};
__name(_IdempotentParameterMismatchException, "IdempotentParameterMismatchException");
var IdempotentParameterMismatchException = _IdempotentParameterMismatchException;
var _TransactionInProgressException = class _TransactionInProgressException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TransactionInProgressException",
      $fault: "client",
      ...opts
    });
    this.name = "TransactionInProgressException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TransactionInProgressException.prototype);
    this.Message = opts.Message;
  }
};
__name(_TransactionInProgressException, "TransactionInProgressException");
var TransactionInProgressException = _TransactionInProgressException;
var _ExportConflictException = class _ExportConflictException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ExportConflictException",
      $fault: "client",
      ...opts
    });
    this.name = "ExportConflictException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ExportConflictException.prototype);
  }
};
__name(_ExportConflictException, "ExportConflictException");
var ExportConflictException = _ExportConflictException;
var _InvalidExportTimeException = class _InvalidExportTimeException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidExportTimeException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidExportTimeException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidExportTimeException.prototype);
  }
};
__name(_InvalidExportTimeException, "InvalidExportTimeException");
var InvalidExportTimeException = _InvalidExportTimeException;
var _PointInTimeRecoveryUnavailableException = class _PointInTimeRecoveryUnavailableException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PointInTimeRecoveryUnavailableException",
      $fault: "client",
      ...opts
    });
    this.name = "PointInTimeRecoveryUnavailableException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PointInTimeRecoveryUnavailableException.prototype);
  }
};
__name(_PointInTimeRecoveryUnavailableException, "PointInTimeRecoveryUnavailableException");
var PointInTimeRecoveryUnavailableException = _PointInTimeRecoveryUnavailableException;
var _ImportConflictException = class _ImportConflictException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ImportConflictException",
      $fault: "client",
      ...opts
    });
    this.name = "ImportConflictException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ImportConflictException.prototype);
  }
};
__name(_ImportConflictException, "ImportConflictException");
var ImportConflictException = _ImportConflictException;
var Select = {
  ALL_ATTRIBUTES: "ALL_ATTRIBUTES",
  ALL_PROJECTED_ATTRIBUTES: "ALL_PROJECTED_ATTRIBUTES",
  COUNT: "COUNT",
  SPECIFIC_ATTRIBUTES: "SPECIFIC_ATTRIBUTES"
};
var _TableAlreadyExistsException = class _TableAlreadyExistsException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TableAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "TableAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TableAlreadyExistsException.prototype);
  }
};
__name(_TableAlreadyExistsException, "TableAlreadyExistsException");
var TableAlreadyExistsException = _TableAlreadyExistsException;
var _InvalidRestoreTimeException = class _InvalidRestoreTimeException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidRestoreTimeException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidRestoreTimeException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidRestoreTimeException.prototype);
  }
};
__name(_InvalidRestoreTimeException, "InvalidRestoreTimeException");
var InvalidRestoreTimeException = _InvalidRestoreTimeException;
var _ReplicaAlreadyExistsException = class _ReplicaAlreadyExistsException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ReplicaAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "ReplicaAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ReplicaAlreadyExistsException.prototype);
  }
};
__name(_ReplicaAlreadyExistsException, "ReplicaAlreadyExistsException");
var ReplicaAlreadyExistsException = _ReplicaAlreadyExistsException;
var _ReplicaNotFoundException = class _ReplicaNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ReplicaNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ReplicaNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ReplicaNotFoundException.prototype);
  }
};
__name(_ReplicaNotFoundException, "ReplicaNotFoundException");
var ReplicaNotFoundException = _ReplicaNotFoundException;
var _IndexNotFoundException = class _IndexNotFoundException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "IndexNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "IndexNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _IndexNotFoundException.prototype);
  }
};
__name(_IndexNotFoundException, "IndexNotFoundException");
var IndexNotFoundException = _IndexNotFoundException;
var AttributeValue;
((AttributeValue2) => {
  AttributeValue2.visit = /* @__PURE__ */ __name((value, visitor) => {
    if (value.S !== void 0)
      return visitor.S(value.S);
    if (value.N !== void 0)
      return visitor.N(value.N);
    if (value.B !== void 0)
      return visitor.B(value.B);
    if (value.SS !== void 0)
      return visitor.SS(value.SS);
    if (value.NS !== void 0)
      return visitor.NS(value.NS);
    if (value.BS !== void 0)
      return visitor.BS(value.BS);
    if (value.M !== void 0)
      return visitor.M(value.M);
    if (value.L !== void 0)
      return visitor.L(value.L);
    if (value.NULL !== void 0)
      return visitor.NULL(value.NULL);
    if (value.BOOL !== void 0)
      return visitor.BOOL(value.BOOL);
    return visitor._(value.$unknown[0], value.$unknown[1]);
  }, "visit");
})(AttributeValue || (AttributeValue = {}));
var _ConditionalCheckFailedException = class _ConditionalCheckFailedException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ConditionalCheckFailedException",
      $fault: "client",
      ...opts
    });
    this.name = "ConditionalCheckFailedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ConditionalCheckFailedException.prototype);
    this.Item = opts.Item;
  }
};
__name(_ConditionalCheckFailedException, "ConditionalCheckFailedException");
var ConditionalCheckFailedException = _ConditionalCheckFailedException;
var _TransactionCanceledException = class _TransactionCanceledException extends DynamoDBServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TransactionCanceledException",
      $fault: "client",
      ...opts
    });
    this.name = "TransactionCanceledException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TransactionCanceledException.prototype);
    this.Message = opts.Message;
    this.CancellationReasons = opts.CancellationReasons;
  }
};
__name(_TransactionCanceledException, "TransactionCanceledException");
var TransactionCanceledException = _TransactionCanceledException;

// src/protocols/Aws_json1_0.ts
var se_BatchExecuteStatementCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("BatchExecuteStatement");
  let body;
  body = JSON.stringify(se_BatchExecuteStatementInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_BatchExecuteStatementCommand");
var se_BatchGetItemCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("BatchGetItem");
  let body;
  body = JSON.stringify(se_BatchGetItemInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_BatchGetItemCommand");
var se_BatchWriteItemCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("BatchWriteItem");
  let body;
  body = JSON.stringify(se_BatchWriteItemInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_BatchWriteItemCommand");
var se_CreateBackupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateBackup");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateBackupCommand");
var se_CreateGlobalTableCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateGlobalTable");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateGlobalTableCommand");
var se_CreateTableCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateTable");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateTableCommand");
var se_DeleteBackupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteBackup");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteBackupCommand");
var se_DeleteItemCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteItem");
  let body;
  body = JSON.stringify(se_DeleteItemInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteItemCommand");
var se_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteResourcePolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteResourcePolicyCommand");
var se_DeleteTableCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteTable");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteTableCommand");
var se_DescribeBackupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeBackup");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeBackupCommand");
var se_DescribeContinuousBackupsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeContinuousBackups");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeContinuousBackupsCommand");
var se_DescribeContributorInsightsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeContributorInsights");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeContributorInsightsCommand");
var se_DescribeEndpointsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeEndpoints");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeEndpointsCommand");
var se_DescribeExportCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeExport");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeExportCommand");
var se_DescribeGlobalTableCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeGlobalTable");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeGlobalTableCommand");
var se_DescribeGlobalTableSettingsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeGlobalTableSettings");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeGlobalTableSettingsCommand");
var se_DescribeImportCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeImport");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeImportCommand");
var se_DescribeKinesisStreamingDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeKinesisStreamingDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeKinesisStreamingDestinationCommand");
var se_DescribeLimitsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeLimits");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeLimitsCommand");
var se_DescribeTableCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeTable");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeTableCommand");
var se_DescribeTableReplicaAutoScalingCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeTableReplicaAutoScaling");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeTableReplicaAutoScalingCommand");
var se_DescribeTimeToLiveCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeTimeToLive");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeTimeToLiveCommand");
var se_DisableKinesisStreamingDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DisableKinesisStreamingDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DisableKinesisStreamingDestinationCommand");
var se_EnableKinesisStreamingDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("EnableKinesisStreamingDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_EnableKinesisStreamingDestinationCommand");
var se_ExecuteStatementCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ExecuteStatement");
  let body;
  body = JSON.stringify(se_ExecuteStatementInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ExecuteStatementCommand");
var se_ExecuteTransactionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ExecuteTransaction");
  let body;
  body = JSON.stringify(se_ExecuteTransactionInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ExecuteTransactionCommand");
var se_ExportTableToPointInTimeCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ExportTableToPointInTime");
  let body;
  body = JSON.stringify(se_ExportTableToPointInTimeInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ExportTableToPointInTimeCommand");
var se_GetItemCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetItem");
  let body;
  body = JSON.stringify(se_GetItemInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetItemCommand");
var se_GetResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetResourcePolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetResourcePolicyCommand");
var se_ImportTableCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ImportTable");
  let body;
  body = JSON.stringify(se_ImportTableInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ImportTableCommand");
var se_ListBackupsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListBackups");
  let body;
  body = JSON.stringify(se_ListBackupsInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListBackupsCommand");
var se_ListContributorInsightsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListContributorInsights");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListContributorInsightsCommand");
var se_ListExportsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListExports");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListExportsCommand");
var se_ListGlobalTablesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListGlobalTables");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListGlobalTablesCommand");
var se_ListImportsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListImports");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListImportsCommand");
var se_ListTablesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListTables");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListTablesCommand");
var se_ListTagsOfResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListTagsOfResource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListTagsOfResourceCommand");
var se_PutItemCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutItem");
  let body;
  body = JSON.stringify(se_PutItemInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutItemCommand");
var se_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutResourcePolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutResourcePolicyCommand");
var se_QueryCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("Query");
  let body;
  body = JSON.stringify(se_QueryInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_QueryCommand");
var se_RestoreTableFromBackupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("RestoreTableFromBackup");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_RestoreTableFromBackupCommand");
var se_RestoreTableToPointInTimeCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("RestoreTableToPointInTime");
  let body;
  body = JSON.stringify(se_RestoreTableToPointInTimeInput(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_RestoreTableToPointInTimeCommand");
var se_ScanCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("Scan");
  let body;
  body = JSON.stringify(se_ScanInput(input, context));
  return buildHttpRpcRequest(context, heade