@aws-sdk/client-s3tables 3.893.0 → 3.895.0

package/dist-cjs/index.js

@@ -1,11 +1,2033 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3TablesServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./S3TablesClient"), exports);
-tslib_1.__exportStar(require("./S3Tables"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-var S3TablesServiceException_1 = require("./models/S3TablesServiceException");
-Object.defineProperty(exports, "S3TablesServiceException", { enumerable: true, get: function () { return S3TablesServiceException_1.S3TablesServiceException; } });
+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 index_exports = {};
+__export(index_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  BadRequestException: () => BadRequestException,
+  ConflictException: () => ConflictException,
+  CreateNamespaceCommand: () => CreateNamespaceCommand,
+  CreateTableBucketCommand: () => CreateTableBucketCommand,
+  CreateTableCommand: () => CreateTableCommand,
+  DeleteNamespaceCommand: () => DeleteNamespaceCommand,
+  DeleteTableBucketCommand: () => DeleteTableBucketCommand,
+  DeleteTableBucketEncryptionCommand: () => DeleteTableBucketEncryptionCommand,
+  DeleteTableBucketPolicyCommand: () => DeleteTableBucketPolicyCommand,
+  DeleteTableCommand: () => DeleteTableCommand,
+  DeleteTablePolicyCommand: () => DeleteTablePolicyCommand,
+  ForbiddenException: () => ForbiddenException,
+  GetNamespaceCommand: () => GetNamespaceCommand,
+  GetTableBucketCommand: () => GetTableBucketCommand,
+  GetTableBucketEncryptionCommand: () => GetTableBucketEncryptionCommand,
+  GetTableBucketMaintenanceConfigurationCommand: () => GetTableBucketMaintenanceConfigurationCommand,
+  GetTableBucketPolicyCommand: () => GetTableBucketPolicyCommand,
+  GetTableCommand: () => GetTableCommand,
+  GetTableEncryptionCommand: () => GetTableEncryptionCommand,
+  GetTableMaintenanceConfigurationCommand: () => GetTableMaintenanceConfigurationCommand,
+  GetTableMaintenanceJobStatusCommand: () => GetTableMaintenanceJobStatusCommand,
+  GetTableMetadataLocationCommand: () => GetTableMetadataLocationCommand,
+  GetTablePolicyCommand: () => GetTablePolicyCommand,
+  IcebergCompactionStrategy: () => IcebergCompactionStrategy,
+  InternalServerErrorException: () => InternalServerErrorException,
+  JobStatus: () => JobStatus,
+  ListNamespacesCommand: () => ListNamespacesCommand,
+  ListTableBucketsCommand: () => ListTableBucketsCommand,
+  ListTablesCommand: () => ListTablesCommand,
+  MaintenanceStatus: () => MaintenanceStatus,
+  NotFoundException: () => NotFoundException,
+  OpenTableFormat: () => OpenTableFormat,
+  PutTableBucketEncryptionCommand: () => PutTableBucketEncryptionCommand,
+  PutTableBucketMaintenanceConfigurationCommand: () => PutTableBucketMaintenanceConfigurationCommand,
+  PutTableBucketPolicyCommand: () => PutTableBucketPolicyCommand,
+  PutTableMaintenanceConfigurationCommand: () => PutTableMaintenanceConfigurationCommand,
+  PutTablePolicyCommand: () => PutTablePolicyCommand,
+  RenameTableCommand: () => RenameTableCommand,
+  S3Tables: () => S3Tables,
+  S3TablesClient: () => S3TablesClient,
+  S3TablesServiceException: () => S3TablesServiceException,
+  SSEAlgorithm: () => SSEAlgorithm,
+  TableBucketMaintenanceSettings: () => TableBucketMaintenanceSettings,
+  TableBucketMaintenanceType: () => TableBucketMaintenanceType,
+  TableBucketType: () => TableBucketType,
+  TableMaintenanceJobType: () => TableMaintenanceJobType,
+  TableMaintenanceSettings: () => TableMaintenanceSettings,
+  TableMaintenanceType: () => TableMaintenanceType,
+  TableMetadata: () => TableMetadata,
+  TableType: () => TableType,
+  TooManyRequestsException: () => TooManyRequestsException,
+  UpdateTableMetadataLocationCommand: () => UpdateTableMetadataLocationCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateListNamespaces: () => paginateListNamespaces,
+  paginateListTableBuckets: () => paginateListTableBuckets,
+  paginateListTables: () => paginateListTables
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/S3TablesClient.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_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_core = require("@smithy/core");
+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");
+
+var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return Object.assign(options, {
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "s3tables"
+  });
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/S3TablesClient.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");
+
+// src/auth/httpAuthExtensionConfiguration.ts
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// src/runtimeExtensions.ts
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = Object.assign(
+    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
+    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
+    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
+    getHttpAuthExtensionConfiguration(runtimeConfig)
+  );
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return Object.assign(
+    runtimeConfig,
+    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
+    resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  );
+}, "resolveRuntimeExtensions");
+
+// src/S3TablesClient.ts
+var S3TablesClient = class extends import_smithy_client.Client {
+  static {
+    __name(this, "S3TablesClient");
+  }
+  /**
+   * The resolved configuration of S3TablesClient class. This is resolved and normalized from the {@link S3TablesClientConfig | constructor configuration interface}.
+   */
+  config;
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    super(_config_0);
+    this.initConfig = _config_0;
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
+    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
+    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
+    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+    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_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultS3TablesHttpAuthSchemeParametersProvider,
+        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
+          "aws.auth#sigv4": config.credentials
+        }), "identityProviderConfigProvider")
+      })
+    );
+    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(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();
+  }
+};
+
+// src/S3Tables.ts
+
+
+// src/commands/CreateNamespaceCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+
+// src/protocols/Aws_restJson1.ts
+var import_core2 = require("@aws-sdk/core");
+
+
+
+// src/models/S3TablesServiceException.ts
+
+var S3TablesServiceException = class _S3TablesServiceException extends import_smithy_client.ServiceException {
+  static {
+    __name(this, "S3TablesServiceException");
+  }
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _S3TablesServiceException.prototype);
+  }
+};
+
+// src/models/models_0.ts
+var AccessDeniedException = class _AccessDeniedException extends S3TablesServiceException {
+  static {
+    __name(this, "AccessDeniedException");
+  }
+  name = "AccessDeniedException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+var BadRequestException = class _BadRequestException extends S3TablesServiceException {
+  static {
+    __name(this, "BadRequestException");
+  }
+  name = "BadRequestException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+  }
+};
+var ConflictException = class _ConflictException extends S3TablesServiceException {
+  static {
+    __name(this, "ConflictException");
+  }
+  name = "ConflictException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+  }
+};
+var ForbiddenException = class _ForbiddenException extends S3TablesServiceException {
+  static {
+    __name(this, "ForbiddenException");
+  }
+  name = "ForbiddenException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ForbiddenException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _ForbiddenException.prototype);
+  }
+};
+var InternalServerErrorException = class _InternalServerErrorException extends S3TablesServiceException {
+  static {
+    __name(this, "InternalServerErrorException");
+  }
+  name = "InternalServerErrorException";
+  $fault = "server";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerErrorException",
+      $fault: "server",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _InternalServerErrorException.prototype);
+  }
+};
+var NotFoundException = class _NotFoundException extends S3TablesServiceException {
+  static {
+    __name(this, "NotFoundException");
+  }
+  name = "NotFoundException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+  }
+};
+var TooManyRequestsException = class _TooManyRequestsException extends S3TablesServiceException {
+  static {
+    __name(this, "TooManyRequestsException");
+  }
+  name = "TooManyRequestsException";
+  $fault = "client";
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyRequestsException",
+      $fault: "client",
+      ...opts
+    });
+    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
+  }
+};
+var SSEAlgorithm = {
+  AES256: "AES256",
+  AWS_KMS: "aws:kms"
+};
+var OpenTableFormat = {
+  ICEBERG: "ICEBERG"
+};
+var TableMetadata;
+((TableMetadata3) => {
+  TableMetadata3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.iceberg !== void 0) return visitor.iceberg(value.iceberg);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(TableMetadata || (TableMetadata = {}));
+var TableType = {
+  AWS: "aws",
+  CUSTOMER: "customer"
+};
+var TableBucketType = {
+  AWS: "aws",
+  CUSTOMER: "customer"
+};
+var TableBucketMaintenanceType = {
+  ICEBERG_UNREFERENCED_FILE_REMOVAL: "icebergUnreferencedFileRemoval"
+};
+var TableBucketMaintenanceSettings;
+((TableBucketMaintenanceSettings3) => {
+  TableBucketMaintenanceSettings3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.icebergUnreferencedFileRemoval !== void 0)
+      return visitor.icebergUnreferencedFileRemoval(value.icebergUnreferencedFileRemoval);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(TableBucketMaintenanceSettings || (TableBucketMaintenanceSettings = {}));
+var MaintenanceStatus = {
+  DISABLED: "disabled",
+  ENABLED: "enabled"
+};
+var TableMaintenanceType = {
+  ICEBERG_COMPACTION: "icebergCompaction",
+  ICEBERG_SNAPSHOT_MANAGEMENT: "icebergSnapshotManagement"
+};
+var IcebergCompactionStrategy = {
+  AUTO: "auto",
+  BINPACK: "binpack",
+  SORT: "sort",
+  ZORDER: "z-order"
+};
+var TableMaintenanceSettings;
+((TableMaintenanceSettings3) => {
+  TableMaintenanceSettings3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.icebergCompaction !== void 0) return visitor.icebergCompaction(value.icebergCompaction);
+    if (value.icebergSnapshotManagement !== void 0)
+      return visitor.icebergSnapshotManagement(value.icebergSnapshotManagement);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(TableMaintenanceSettings || (TableMaintenanceSettings = {}));
+var TableMaintenanceJobType = {
+  ICEBERG_COMPACTION: "icebergCompaction",
+  ICEBERG_SNAPSHOT_MANAGEMENT: "icebergSnapshotManagement",
+  ICEBERG_UNREFERENCED_FILE_REMOVAL: "icebergUnreferencedFileRemoval"
+};
+var JobStatus = {
+  DISABLED: "Disabled",
+  FAILED: "Failed",
+  NOT_YET_RUN: "Not_Yet_Run",
+  SUCCESSFUL: "Successful"
+};
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/namespaces/{tableBucketARN}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      namespace: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "namespace")
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CreateNamespaceCommand");
+var se_CreateTableCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tables/{tableBucketARN}/{namespace}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      encryptionConfiguration: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "encryptionConfiguration"),
+      format: [],
+      metadata: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "metadata"),
+      name: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CreateTableCommand");
+var se_CreateTableBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/buckets");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      encryptionConfiguration: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "encryptionConfiguration"),
+      name: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CreateTableBucketCommand");
+var se_DeleteNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/namespaces/{tableBucketARN}/{namespace}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteNamespaceCommand");
+var se_DeleteTableCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  const query = (0, import_smithy_client.map)({
+    [_vT]: [, input[_vT]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteTableCommand");
+var se_DeleteTableBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/buckets/{tableBucketARN}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteTableBucketCommand");
+var se_DeleteTableBucketEncryptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/buckets/{tableBucketARN}/encryption");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteTableBucketEncryptionCommand");
+var se_DeleteTableBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/buckets/{tableBucketARN}/policy");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteTableBucketPolicyCommand");
+var se_DeleteTablePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/policy");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteTablePolicyCommand");
+var se_GetNamespaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/namespaces/{tableBucketARN}/{namespace}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetNamespaceCommand");
+var se_GetTableCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/get-table");
+  const query = (0, import_smithy_client.map)({
+    [_tBARN]: [, input[_tBARN]],
+    [_n]: [, input[_n]],
+    [_na]: [, input[_na]],
+    [_tA]: [, input[_tA]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetTableCommand");
+var se_GetTableBucketCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/buckets/{tableBucketARN}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTableBucketCommand");
+var se_GetTableBucketEncryptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/buckets/{tableBucketARN}/encryption");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTableBucketEncryptionCommand");
+var se_GetTableBucketMaintenanceConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/buckets/{tableBucketARN}/maintenance");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTableBucketMaintenanceConfigurationCommand");
+var se_GetTableBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/buckets/{tableBucketARN}/policy");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTableBucketPolicyCommand");
+var se_GetTableEncryptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/encryption");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTableEncryptionCommand");
+var se_GetTableMaintenanceConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/maintenance");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTableMaintenanceConfigurationCommand");
+var se_GetTableMaintenanceJobStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/maintenance-job-status");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTableMaintenanceJobStatusCommand");
+var se_GetTableMetadataLocationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/metadata-location");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTableMetadataLocationCommand");
+var se_GetTablePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/policy");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetTablePolicyCommand");
+var se_ListNamespacesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/namespaces/{tableBucketARN}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  const query = (0, import_smithy_client.map)({
+    [_p]: [, input[_p]],
+    [_cT]: [, input[_cT]],
+    [_mN]: [() => input.maxNamespaces !== void 0, () => input[_mN].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListNamespacesCommand");
+var se_ListTableBucketsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/buckets");
+  const query = (0, import_smithy_client.map)({
+    [_p]: [, input[_p]],
+    [_cT]: [, input[_cT]],
+    [_mB]: [() => input.maxBuckets !== void 0, () => input[_mB].toString()],
+    [_t]: [, input[_t]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListTableBucketsCommand");
+var se_ListTablesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tables/{tableBucketARN}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  const query = (0, import_smithy_client.map)({
+    [_n]: [, input[_n]],
+    [_p]: [, input[_p]],
+    [_cT]: [, input[_cT]],
+    [_mT]: [() => input.maxTables !== void 0, () => input[_mT].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListTablesCommand");
+var se_PutTableBucketEncryptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/buckets/{tableBucketARN}/encryption");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      encryptionConfiguration: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "encryptionConfiguration")
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutTableBucketEncryptionCommand");
+var se_PutTableBucketMaintenanceConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/buckets/{tableBucketARN}/maintenance/{type}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("type", () => input.type, "{type}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      value: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "value")
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutTableBucketMaintenanceConfigurationCommand");
+var se_PutTableBucketPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/buckets/{tableBucketARN}/policy");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourcePolicy: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutTableBucketPolicyCommand");
+var se_PutTableMaintenanceConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/maintenance/{type}");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  b.p("type", () => input.type, "{type}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      value: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "value")
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutTableMaintenanceConfigurationCommand");
+var se_PutTablePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/policy");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      resourcePolicy: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutTablePolicyCommand");
+var se_RenameTableCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/rename");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      newName: [],
+      newNamespaceName: [],
+      versionToken: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_RenameTableCommand");
+var se_UpdateTableMetadataLocationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tables/{tableBucketARN}/{namespace}/{name}/metadata-location");
+  b.p("tableBucketARN", () => input.tableBucketARN, "{tableBucketARN}", false);
+  b.p("namespace", () => input.namespace, "{namespace}", false);
+  b.p("name", () => input.name, "{name}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      metadataLocation: [],
+      versionToken: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateTableMetadataLocationCommand");
+var de_CreateNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    namespace: import_smithy_client._json,
+    tableBucketARN: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateNamespaceCommand");
+var de_CreateTableCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    tableARN: import_smithy_client.expectString,
+    versionToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateTableCommand");
+var de_CreateTableBucketCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateTableBucketCommand");
+var de_DeleteNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteNamespaceCommand");
+var de_DeleteTableCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteTableCommand");
+var de_DeleteTableBucketCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteTableBucketCommand");
+var de_DeleteTableBucketEncryptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteTableBucketEncryptionCommand");
+var de_DeleteTableBucketPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteTableBucketPolicyCommand");
+var de_DeleteTablePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteTablePolicyCommand");
+var de_GetNamespaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createdAt"),
+    createdBy: import_smithy_client.expectString,
+    namespace: import_smithy_client._json,
+    namespaceId: import_smithy_client.expectString,
+    ownerAccountId: import_smithy_client.expectString,
+    tableBucketId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetNamespaceCommand");
+var de_GetTableCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createdAt"),
+    createdBy: import_smithy_client.expectString,
+    format: import_smithy_client.expectString,
+    managedByService: import_smithy_client.expectString,
+    metadataLocation: import_smithy_client.expectString,
+    modifiedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "modifiedAt"),
+    modifiedBy: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    namespace: import_smithy_client._json,
+    namespaceId: import_smithy_client.expectString,
+    ownerAccountId: import_smithy_client.expectString,
+    tableARN: import_smithy_client.expectString,
+    tableBucketId: import_smithy_client.expectString,
+    type: import_smithy_client.expectString,
+    versionToken: import_smithy_client.expectString,
+    warehouseLocation: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableCommand");
+var de_GetTableBucketCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString,
+    createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createdAt"),
+    name: import_smithy_client.expectString,
+    ownerAccountId: import_smithy_client.expectString,
+    tableBucketId: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableBucketCommand");
+var de_GetTableBucketEncryptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    encryptionConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableBucketEncryptionCommand");
+var de_GetTableBucketMaintenanceConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    configuration: import_smithy_client._json,
+    tableBucketARN: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableBucketMaintenanceConfigurationCommand");
+var de_GetTableBucketPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    resourcePolicy: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableBucketPolicyCommand");
+var de_GetTableEncryptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    encryptionConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableEncryptionCommand");
+var de_GetTableMaintenanceConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    configuration: import_smithy_client._json,
+    tableARN: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableMaintenanceConfigurationCommand");
+var de_GetTableMaintenanceJobStatusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    status: /* @__PURE__ */ __name((_) => de_TableMaintenanceJobStatus(_, context), "status"),
+    tableARN: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableMaintenanceJobStatusCommand");
+var de_GetTableMetadataLocationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    metadataLocation: import_smithy_client.expectString,
+    versionToken: import_smithy_client.expectString,
+    warehouseLocation: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTableMetadataLocationCommand");
+var de_GetTablePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    resourcePolicy: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTablePolicyCommand");
+var de_ListNamespacesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    continuationToken: import_smithy_client.expectString,
+    namespaces: /* @__PURE__ */ __name((_) => de_NamespaceSummaryList(_, context), "namespaces")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListNamespacesCommand");
+var de_ListTableBucketsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    continuationToken: import_smithy_client.expectString,
+    tableBuckets: /* @__PURE__ */ __name((_) => de_TableBucketSummaryList(_, context), "tableBuckets")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTableBucketsCommand");
+var de_ListTablesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    continuationToken: import_smithy_client.expectString,
+    tables: /* @__PURE__ */ __name((_) => de_TableSummaryList(_, context), "tables")
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTablesCommand");
+var de_PutTableBucketEncryptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutTableBucketEncryptionCommand");
+var de_PutTableBucketMaintenanceConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutTableBucketMaintenanceConfigurationCommand");
+var de_PutTableBucketPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutTableBucketPolicyCommand");
+var de_PutTableMaintenanceConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutTableMaintenanceConfigurationCommand");
+var de_PutTablePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutTablePolicyCommand");
+var de_RenameTableCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_RenameTableCommand");
+var de_UpdateTableMetadataLocationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    metadataLocation: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    namespace: import_smithy_client._json,
+    tableARN: import_smithy_client.expectString,
+    versionToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateTableMetadataLocationCommand");
+var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
+  };
+  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.s3tables#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.s3tables#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.s3tables#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.s3tables#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.s3tables#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.s3tables#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "AccessDeniedException":
+    case "com.amazonaws.s3tables#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(S3TablesServiceException);
+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_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_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_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, {
+    message: import_smithy_client.expectString
+  });
+  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_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_TooManyRequestsExceptionRes = /* @__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 TooManyRequestsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyRequestsExceptionRes");
+var de_NamespaceSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createdAt"),
+    createdBy: import_smithy_client.expectString,
+    namespace: import_smithy_client._json,
+    namespaceId: import_smithy_client.expectString,
+    ownerAccountId: import_smithy_client.expectString,
+    tableBucketId: import_smithy_client.expectString
+  });
+}, "de_NamespaceSummary");
+var de_NamespaceSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_NamespaceSummary(entry, context);
+  });
+  return retVal;
+}, "de_NamespaceSummaryList");
+var de_TableBucketSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createdAt"),
+    name: import_smithy_client.expectString,
+    ownerAccountId: import_smithy_client.expectString,
+    tableBucketId: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+}, "de_TableBucketSummary");
+var de_TableBucketSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TableBucketSummary(entry, context);
+  });
+  return retVal;
+}, "de_TableBucketSummaryList");
+var de_TableMaintenanceJobStatus = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce(
+    (acc, [key, value]) => {
+      if (value === null) {
+        return acc;
+      }
+      acc[key] = de_TableMaintenanceJobStatusValue(value, context);
+      return acc;
+    },
+    {}
+  );
+}, "de_TableMaintenanceJobStatus");
+var de_TableMaintenanceJobStatusValue = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failureMessage: import_smithy_client.expectString,
+    lastRunTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "lastRunTimestamp"),
+    status: import_smithy_client.expectString
+  });
+}, "de_TableMaintenanceJobStatusValue");
+var de_TableSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    createdAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "createdAt"),
+    modifiedAt: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), "modifiedAt"),
+    name: import_smithy_client.expectString,
+    namespace: import_smithy_client._json,
+    namespaceId: import_smithy_client.expectString,
+    tableARN: import_smithy_client.expectString,
+    tableBucketId: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+}, "de_TableSummary");
+var de_TableSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TableSummary(entry, context);
+  });
+  return retVal;
+}, "de_TableSummaryList");
+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 _cT = "continuationToken";
+var _mB = "maxBuckets";
+var _mN = "maxNamespaces";
+var _mT = "maxTables";
+var _n = "namespace";
+var _na = "name";
+var _p = "prefix";
+var _t = "type";
+var _tA = "tableArn";
+var _tBARN = "tableBucketARN";
+var _vT = "versionToken";
+
+// src/commands/CreateNamespaceCommand.ts
+var CreateNamespaceCommand = class 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("S3TableBuckets", "CreateNamespace", {}).n("S3TablesClient", "CreateNamespaceCommand").f(void 0, void 0).ser(se_CreateNamespaceCommand).de(de_CreateNamespaceCommand).build() {
+  static {
+    __name(this, "CreateNamespaceCommand");
+  }
+};
+
+// src/commands/CreateTableBucketCommand.ts
+
+
+
+var CreateTableBucketCommand = class 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("S3TableBuckets", "CreateTableBucket", {}).n("S3TablesClient", "CreateTableBucketCommand").f(void 0, void 0).ser(se_CreateTableBucketCommand).de(de_CreateTableBucketCommand).build() {
+  static {
+    __name(this, "CreateTableBucketCommand");
+  }
+};
+
+// src/commands/CreateTableCommand.ts
+
+
+
+var CreateTableCommand = class 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("S3TableBuckets", "CreateTable", {}).n("S3TablesClient", "CreateTableCommand").f(void 0, void 0).ser(se_CreateTableCommand).de(de_CreateTableCommand).build() {
+  static {
+    __name(this, "CreateTableCommand");
+  }
+};
+
+// src/commands/DeleteNamespaceCommand.ts
+
+
+
+var DeleteNamespaceCommand = class 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("S3TableBuckets", "DeleteNamespace", {}).n("S3TablesClient", "DeleteNamespaceCommand").f(void 0, void 0).ser(se_DeleteNamespaceCommand).de(de_DeleteNamespaceCommand).build() {
+  static {
+    __name(this, "DeleteNamespaceCommand");
+  }
+};
+
+// src/commands/DeleteTableBucketCommand.ts
+
+
+
+var DeleteTableBucketCommand = class 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("S3TableBuckets", "DeleteTableBucket", {}).n("S3TablesClient", "DeleteTableBucketCommand").f(void 0, void 0).ser(se_DeleteTableBucketCommand).de(de_DeleteTableBucketCommand).build() {
+  static {
+    __name(this, "DeleteTableBucketCommand");
+  }
+};
+
+// src/commands/DeleteTableBucketEncryptionCommand.ts
+
+
+
+var DeleteTableBucketEncryptionCommand = class 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("S3TableBuckets", "DeleteTableBucketEncryption", {}).n("S3TablesClient", "DeleteTableBucketEncryptionCommand").f(void 0, void 0).ser(se_DeleteTableBucketEncryptionCommand).de(de_DeleteTableBucketEncryptionCommand).build() {
+  static {
+    __name(this, "DeleteTableBucketEncryptionCommand");
+  }
+};
+
+// src/commands/DeleteTableBucketPolicyCommand.ts
+
+
+
+var DeleteTableBucketPolicyCommand = class 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("S3TableBuckets", "DeleteTableBucketPolicy", {}).n("S3TablesClient", "DeleteTableBucketPolicyCommand").f(void 0, void 0).ser(se_DeleteTableBucketPolicyCommand).de(de_DeleteTableBucketPolicyCommand).build() {
+  static {
+    __name(this, "DeleteTableBucketPolicyCommand");
+  }
+};
+
+// src/commands/DeleteTableCommand.ts
+
+
+
+var DeleteTableCommand = class 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("S3TableBuckets", "DeleteTable", {}).n("S3TablesClient", "DeleteTableCommand").f(void 0, void 0).ser(se_DeleteTableCommand).de(de_DeleteTableCommand).build() {
+  static {
+    __name(this, "DeleteTableCommand");
+  }
+};
+
+// src/commands/DeleteTablePolicyCommand.ts
+
+
+
+var DeleteTablePolicyCommand = class 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("S3TableBuckets", "DeleteTablePolicy", {}).n("S3TablesClient", "DeleteTablePolicyCommand").f(void 0, void 0).ser(se_DeleteTablePolicyCommand).de(de_DeleteTablePolicyCommand).build() {
+  static {
+    __name(this, "DeleteTablePolicyCommand");
+  }
+};
+
+// src/commands/GetNamespaceCommand.ts
+
+
+
+var GetNamespaceCommand = class 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("S3TableBuckets", "GetNamespace", {}).n("S3TablesClient", "GetNamespaceCommand").f(void 0, void 0).ser(se_GetNamespaceCommand).de(de_GetNamespaceCommand).build() {
+  static {
+    __name(this, "GetNamespaceCommand");
+  }
+};
+
+// src/commands/GetTableBucketCommand.ts
+
+
+
+var GetTableBucketCommand = class 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("S3TableBuckets", "GetTableBucket", {}).n("S3TablesClient", "GetTableBucketCommand").f(void 0, void 0).ser(se_GetTableBucketCommand).de(de_GetTableBucketCommand).build() {
+  static {
+    __name(this, "GetTableBucketCommand");
+  }
+};
+
+// src/commands/GetTableBucketEncryptionCommand.ts
+
+
+
+var GetTableBucketEncryptionCommand = class 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("S3TableBuckets", "GetTableBucketEncryption", {}).n("S3TablesClient", "GetTableBucketEncryptionCommand").f(void 0, void 0).ser(se_GetTableBucketEncryptionCommand).de(de_GetTableBucketEncryptionCommand).build() {
+  static {
+    __name(this, "GetTableBucketEncryptionCommand");
+  }
+};
+
+// src/commands/GetTableBucketMaintenanceConfigurationCommand.ts
+
+
+
+var GetTableBucketMaintenanceConfigurationCommand = class 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("S3TableBuckets", "GetTableBucketMaintenanceConfiguration", {}).n("S3TablesClient", "GetTableBucketMaintenanceConfigurationCommand").f(void 0, void 0).ser(se_GetTableBucketMaintenanceConfigurationCommand).de(de_GetTableBucketMaintenanceConfigurationCommand).build() {
+  static {
+    __name(this, "GetTableBucketMaintenanceConfigurationCommand");
+  }
+};
+
+// src/commands/GetTableBucketPolicyCommand.ts
+
+
+
+var GetTableBucketPolicyCommand = class 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("S3TableBuckets", "GetTableBucketPolicy", {}).n("S3TablesClient", "GetTableBucketPolicyCommand").f(void 0, void 0).ser(se_GetTableBucketPolicyCommand).de(de_GetTableBucketPolicyCommand).build() {
+  static {
+    __name(this, "GetTableBucketPolicyCommand");
+  }
+};
+
+// src/commands/GetTableCommand.ts
+
+
+
+var GetTableCommand = class 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("S3TableBuckets", "GetTable", {}).n("S3TablesClient", "GetTableCommand").f(void 0, void 0).ser(se_GetTableCommand).de(de_GetTableCommand).build() {
+  static {
+    __name(this, "GetTableCommand");
+  }
+};
+
+// src/commands/GetTableEncryptionCommand.ts
+
+
+
+var GetTableEncryptionCommand = class 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("S3TableBuckets", "GetTableEncryption", {}).n("S3TablesClient", "GetTableEncryptionCommand").f(void 0, void 0).ser(se_GetTableEncryptionCommand).de(de_GetTableEncryptionCommand).build() {
+  static {
+    __name(this, "GetTableEncryptionCommand");
+  }
+};
+
+// src/commands/GetTableMaintenanceConfigurationCommand.ts
+
+
+
+var GetTableMaintenanceConfigurationCommand = class 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("S3TableBuckets", "GetTableMaintenanceConfiguration", {}).n("S3TablesClient", "GetTableMaintenanceConfigurationCommand").f(void 0, void 0).ser(se_GetTableMaintenanceConfigurationCommand).de(de_GetTableMaintenanceConfigurationCommand).build() {
+  static {
+    __name(this, "GetTableMaintenanceConfigurationCommand");
+  }
+};
+
+// src/commands/GetTableMaintenanceJobStatusCommand.ts
+
+
+
+var GetTableMaintenanceJobStatusCommand = class 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("S3TableBuckets", "GetTableMaintenanceJobStatus", {}).n("S3TablesClient", "GetTableMaintenanceJobStatusCommand").f(void 0, void 0).ser(se_GetTableMaintenanceJobStatusCommand).de(de_GetTableMaintenanceJobStatusCommand).build() {
+  static {
+    __name(this, "GetTableMaintenanceJobStatusCommand");
+  }
+};
+
+// src/commands/GetTableMetadataLocationCommand.ts
+
+
+
+var GetTableMetadataLocationCommand = class 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("S3TableBuckets", "GetTableMetadataLocation", {}).n("S3TablesClient", "GetTableMetadataLocationCommand").f(void 0, void 0).ser(se_GetTableMetadataLocationCommand).de(de_GetTableMetadataLocationCommand).build() {
+  static {
+    __name(this, "GetTableMetadataLocationCommand");
+  }
+};
+
+// src/commands/GetTablePolicyCommand.ts
+
+
+
+var GetTablePolicyCommand = class 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("S3TableBuckets", "GetTablePolicy", {}).n("S3TablesClient", "GetTablePolicyCommand").f(void 0, void 0).ser(se_GetTablePolicyCommand).de(de_GetTablePolicyCommand).build() {
+  static {
+    __name(this, "GetTablePolicyCommand");
+  }
+};
+
+// src/commands/ListNamespacesCommand.ts
+
+
+
+var ListNamespacesCommand = class 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("S3TableBuckets", "ListNamespaces", {}).n("S3TablesClient", "ListNamespacesCommand").f(void 0, void 0).ser(se_ListNamespacesCommand).de(de_ListNamespacesCommand).build() {
+  static {
+    __name(this, "ListNamespacesCommand");
+  }
+};
+
+// src/commands/ListTableBucketsCommand.ts
+
+
+
+var ListTableBucketsCommand = class 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("S3TableBuckets", "ListTableBuckets", {}).n("S3TablesClient", "ListTableBucketsCommand").f(void 0, void 0).ser(se_ListTableBucketsCommand).de(de_ListTableBucketsCommand).build() {
+  static {
+    __name(this, "ListTableBucketsCommand");
+  }
+};
+
+// src/commands/ListTablesCommand.ts
+
+
+
+var ListTablesCommand = class 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("S3TableBuckets", "ListTables", {}).n("S3TablesClient", "ListTablesCommand").f(void 0, void 0).ser(se_ListTablesCommand).de(de_ListTablesCommand).build() {
+  static {
+    __name(this, "ListTablesCommand");
+  }
+};
+
+// src/commands/PutTableBucketEncryptionCommand.ts
+
+
+
+var PutTableBucketEncryptionCommand = class 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("S3TableBuckets", "PutTableBucketEncryption", {}).n("S3TablesClient", "PutTableBucketEncryptionCommand").f(void 0, void 0).ser(se_PutTableBucketEncryptionCommand).de(de_PutTableBucketEncryptionCommand).build() {
+  static {
+    __name(this, "PutTableBucketEncryptionCommand");
+  }
+};
+
+// src/commands/PutTableBucketMaintenanceConfigurationCommand.ts
+
+
+
+var PutTableBucketMaintenanceConfigurationCommand = class 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("S3TableBuckets", "PutTableBucketMaintenanceConfiguration", {}).n("S3TablesClient", "PutTableBucketMaintenanceConfigurationCommand").f(void 0, void 0).ser(se_PutTableBucketMaintenanceConfigurationCommand).de(de_PutTableBucketMaintenanceConfigurationCommand).build() {
+  static {
+    __name(this, "PutTableBucketMaintenanceConfigurationCommand");
+  }
+};
+
+// src/commands/PutTableBucketPolicyCommand.ts
+
+
+
+var PutTableBucketPolicyCommand = class 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("S3TableBuckets", "PutTableBucketPolicy", {}).n("S3TablesClient", "PutTableBucketPolicyCommand").f(void 0, void 0).ser(se_PutTableBucketPolicyCommand).de(de_PutTableBucketPolicyCommand).build() {
+  static {
+    __name(this, "PutTableBucketPolicyCommand");
+  }
+};
+
+// src/commands/PutTableMaintenanceConfigurationCommand.ts
+
+
+
+var PutTableMaintenanceConfigurationCommand = class 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("S3TableBuckets", "PutTableMaintenanceConfiguration", {}).n("S3TablesClient", "PutTableMaintenanceConfigurationCommand").f(void 0, void 0).ser(se_PutTableMaintenanceConfigurationCommand).de(de_PutTableMaintenanceConfigurationCommand).build() {
+  static {
+    __name(this, "PutTableMaintenanceConfigurationCommand");
+  }
+};
+
+// src/commands/PutTablePolicyCommand.ts
+
+
+
+var PutTablePolicyCommand = class 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("S3TableBuckets", "PutTablePolicy", {}).n("S3TablesClient", "PutTablePolicyCommand").f(void 0, void 0).ser(se_PutTablePolicyCommand).de(de_PutTablePolicyCommand).build() {
+  static {
+    __name(this, "PutTablePolicyCommand");
+  }
+};
+
+// src/commands/RenameTableCommand.ts
+
+
+
+var RenameTableCommand = class 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("S3TableBuckets", "RenameTable", {}).n("S3TablesClient", "RenameTableCommand").f(void 0, void 0).ser(se_RenameTableCommand).de(de_RenameTableCommand).build() {
+  static {
+    __name(this, "RenameTableCommand");
+  }
+};
+
+// src/commands/UpdateTableMetadataLocationCommand.ts
+
+
+
+var UpdateTableMetadataLocationCommand = class 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("S3TableBuckets", "UpdateTableMetadataLocation", {}).n("S3TablesClient", "UpdateTableMetadataLocationCommand").f(void 0, void 0).ser(se_UpdateTableMetadataLocationCommand).de(de_UpdateTableMetadataLocationCommand).build() {
+  static {
+    __name(this, "UpdateTableMetadataLocationCommand");
+  }
+};
+
+// src/S3Tables.ts
+var commands = {
+  CreateNamespaceCommand,
+  CreateTableCommand,
+  CreateTableBucketCommand,
+  DeleteNamespaceCommand,
+  DeleteTableCommand,
+  DeleteTableBucketCommand,
+  DeleteTableBucketEncryptionCommand,
+  DeleteTableBucketPolicyCommand,
+  DeleteTablePolicyCommand,
+  GetNamespaceCommand,
+  GetTableCommand,
+  GetTableBucketCommand,
+  GetTableBucketEncryptionCommand,
+  GetTableBucketMaintenanceConfigurationCommand,
+  GetTableBucketPolicyCommand,
+  GetTableEncryptionCommand,
+  GetTableMaintenanceConfigurationCommand,
+  GetTableMaintenanceJobStatusCommand,
+  GetTableMetadataLocationCommand,
+  GetTablePolicyCommand,
+  ListNamespacesCommand,
+  ListTableBucketsCommand,
+  ListTablesCommand,
+  PutTableBucketEncryptionCommand,
+  PutTableBucketMaintenanceConfigurationCommand,
+  PutTableBucketPolicyCommand,
+  PutTableMaintenanceConfigurationCommand,
+  PutTablePolicyCommand,
+  RenameTableCommand,
+  UpdateTableMetadataLocationCommand
+};
+var S3Tables = class extends S3TablesClient {
+  static {
+    __name(this, "S3Tables");
+  }
+};
+(0, import_smithy_client.createAggregatedClient)(commands, S3Tables);
+
+// src/pagination/ListNamespacesPaginator.ts
+
+var paginateListNamespaces = (0, import_core.createPaginator)(S3TablesClient, ListNamespacesCommand, "continuationToken", "continuationToken", "maxNamespaces");
+
+// src/pagination/ListTableBucketsPaginator.ts
+
+var paginateListTableBuckets = (0, import_core.createPaginator)(S3TablesClient, ListTableBucketsCommand, "continuationToken", "continuationToken", "maxBuckets");
+
+// src/pagination/ListTablesPaginator.ts
+
+var paginateListTables = (0, import_core.createPaginator)(S3TablesClient, ListTablesCommand, "continuationToken", "continuationToken", "maxTables");
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  S3TablesServiceException,
+  __Client,
+  S3TablesClient,
+  S3Tables,
+  $Command,
+  CreateNamespaceCommand,
+  CreateTableBucketCommand,
+  CreateTableCommand,
+  DeleteNamespaceCommand,
+  DeleteTableBucketCommand,
+  DeleteTableBucketEncryptionCommand,
+  DeleteTableBucketPolicyCommand,
+  DeleteTableCommand,
+  DeleteTablePolicyCommand,
+  GetNamespaceCommand,
+  GetTableBucketCommand,
+  GetTableBucketEncryptionCommand,
+  GetTableBucketMaintenanceConfigurationCommand,
+  GetTableBucketPolicyCommand,
+  GetTableCommand,
+  GetTableEncryptionCommand,
+  GetTableMaintenanceConfigurationCommand,
+  GetTableMaintenanceJobStatusCommand,
+  GetTableMetadataLocationCommand,
+  GetTablePolicyCommand,
+  ListNamespacesCommand,
+  ListTableBucketsCommand,
+  ListTablesCommand,
+  PutTableBucketEncryptionCommand,
+  PutTableBucketMaintenanceConfigurationCommand,
+  PutTableBucketPolicyCommand,
+  PutTableMaintenanceConfigurationCommand,
+  PutTablePolicyCommand,
+  RenameTableCommand,
+  UpdateTableMetadataLocationCommand,
+  paginateListNamespaces,
+  paginateListTableBuckets,
+  paginateListTables,
+  AccessDeniedException,
+  BadRequestException,
+  ConflictException,
+  ForbiddenException,
+  InternalServerErrorException,
+  NotFoundException,
+  TooManyRequestsException,
+  SSEAlgorithm,
+  OpenTableFormat,
+  TableMetadata,
+  TableType,
+  TableBucketType,
+  TableBucketMaintenanceType,
+  TableBucketMaintenanceSettings,
+  MaintenanceStatus,
+  TableMaintenanceType,
+  IcebergCompactionStrategy,
+  TableMaintenanceSettings,
+  TableMaintenanceJobType,
+  JobStatus
+});
+