@aws-sdk/client-dynamodb 3.1067.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,20 +1,23 @@
-'use strict';
-
-var accountIdEndpoint = require('@aws-sdk/core/account-id-endpoint');
-var client$1 = require('@aws-sdk/core/client');
-var middlewareEndpointDiscovery = require('@aws-sdk/middleware-endpoint-discovery');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var schemas_0 = require('./schemas/schemas_0');
-var runtimeConfig = require('./runtimeConfig');
-var errors = require('./models/errors');
-var DynamoDBServiceException = require('./models/DynamoDBServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { resolveAccountIdEndpointModeConfig } = require("@aws-sdk/core/account-id-endpoint");
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { resolveEndpointDiscoveryConfig } = require("@aws-sdk/middleware-endpoint-discovery");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { Command, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { getEndpointPlugin, resolveEndpointConfig } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, Retry, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultDynamoDBHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { DescribeEndpoints$, BatchExecuteStatement$, BatchGetItem$, BatchWriteItem$, CreateBackup$, CreateGlobalTable$, CreateTable$, DeleteBackup$, DeleteItem$, DeleteResourcePolicy$, DeleteTable$, DescribeBackup$, DescribeContinuousBackups$, DescribeContributorInsights$, DescribeExport$, DescribeGlobalTable$, DescribeGlobalTableSettings$, DescribeImport$, DescribeKinesisStreamingDestination$, DescribeLimits$, DescribeTable$, DescribeTableReplicaAutoScaling$, DescribeTimeToLive$, DisableKinesisStreamingDestination$, EnableKinesisStreamingDestination$, ExecuteStatement$, ExecuteTransaction$, ExportTableToPointInTime$, GetItem$, GetResourcePolicy$, ImportTable$, ListBackups$, ListContributorInsights$, ListExports$, ListGlobalTables$, ListImports$, ListTables$, ListTagsOfResource$, PutItem$, PutResourcePolicy$, Query$, RestoreTableFromBackup$, RestoreTableToPointInTime$, Scan$, TagResource$, TransactGetItems$, TransactWriteItems$, UntagResource$, UpdateContinuousBackups$, UpdateContributorInsights$, UpdateGlobalTable$, UpdateGlobalTableSettings$, UpdateItem$, UpdateKinesisStreamingDestination$, UpdateTable$, UpdateTableReplicaAutoScaling$, UpdateTimeToLive$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+const { getRuntimeConfig } = require("./runtimeConfig");
+__exportStar(require("./models/errors"), exports);
+const { DynamoDBServiceException } = require("./models/DynamoDBServiceException");
+exports.DynamoDBServiceException = DynamoDBServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -32,15 +35,15 @@ const commonParams = {
     AccountIdEndpointMode: { type: "builtInParams", name: "accountIdEndpointMode" },
 };
 
-class DescribeEndpointsCommand extends client.Command
+class DescribeEndpointsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeEndpoints", {})
     .n("DynamoDBClient", "DescribeEndpointsCommand")
-    .sc(schemas_0.DescribeEndpoints$)
+    .sc(DescribeEndpoints$)
     .build() {
 }
 
@@ -84,893 +87,893 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class DynamoDBClient extends client.Client {
+class DynamoDBClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = accountIdEndpoint.resolveAccountIdEndpointModeConfig(_config_1);
-        const _config_3 = client$1.resolveUserAgentConfig(_config_2);
-        const _config_4 = retry.resolveRetryConfig(_config_3, { defaultBaseDelay: retry.Retry.v2026 ? 25 : undefined, defaultMaxAttempts: retry.Retry.v2026 ? 4 : undefined });
-        const _config_5 = config.resolveRegionConfig(_config_4);
-        const _config_6 = client$1.resolveHostHeaderConfig(_config_5);
-        const _config_7 = endpoints.resolveEndpointConfig(_config_6);
-        const _config_8 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_7);
-        const _config_9 = middlewareEndpointDiscovery.resolveEndpointDiscoveryConfig(_config_8, { endpointDiscoveryCommandCtor: DescribeEndpointsCommand });
+        const _config_2 = resolveAccountIdEndpointModeConfig(_config_1);
+        const _config_3 = resolveUserAgentConfig(_config_2);
+        const _config_4 = resolveRetryConfig(_config_3, { defaultBaseDelay: Retry.v2026 ? 25 : undefined, defaultMaxAttempts: Retry.v2026 ? 4 : undefined });
+        const _config_5 = resolveRegionConfig(_config_4);
+        const _config_6 = resolveHostHeaderConfig(_config_5);
+        const _config_7 = resolveEndpointConfig(_config_6);
+        const _config_8 = resolveHttpAuthSchemeConfig(_config_7);
+        const _config_9 = resolveEndpointDiscoveryConfig(_config_8, { endpointDiscoveryCommandCtor: DescribeEndpointsCommand });
         const _config_10 = resolveRuntimeExtensions(_config_9, configuration?.extensions || []);
         this.config = _config_10;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultDynamoDBHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultDynamoDBHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class BatchExecuteStatementCommand extends client.Command
+class BatchExecuteStatementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "BatchExecuteStatement", {})
     .n("DynamoDBClient", "BatchExecuteStatementCommand")
-    .sc(schemas_0.BatchExecuteStatement$)
+    .sc(BatchExecuteStatement$)
     .build() {
 }
 
-class BatchGetItemCommand extends client.Command
+class BatchGetItemCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArnList: { type: "operationContextParams", get: (input) => Object.keys(input?.RequestItems ?? {}) },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "BatchGetItem", {})
     .n("DynamoDBClient", "BatchGetItemCommand")
-    .sc(schemas_0.BatchGetItem$)
+    .sc(BatchGetItem$)
     .build() {
 }
 
-class BatchWriteItemCommand extends client.Command
+class BatchWriteItemCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArnList: { type: "operationContextParams", get: (input) => Object.keys(input?.RequestItems ?? {}) },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "BatchWriteItem", {})
     .n("DynamoDBClient", "BatchWriteItemCommand")
-    .sc(schemas_0.BatchWriteItem$)
+    .sc(BatchWriteItem$)
     .build() {
 }
 
-class CreateBackupCommand extends client.Command
+class CreateBackupCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "CreateBackup", {})
     .n("DynamoDBClient", "CreateBackupCommand")
-    .sc(schemas_0.CreateBackup$)
+    .sc(CreateBackup$)
     .build() {
 }
 
-class CreateGlobalTableCommand extends client.Command
+class CreateGlobalTableCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "GlobalTableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "CreateGlobalTable", {})
     .n("DynamoDBClient", "CreateGlobalTableCommand")
-    .sc(schemas_0.CreateGlobalTable$)
+    .sc(CreateGlobalTable$)
     .build() {
 }
 
-class CreateTableCommand extends client.Command
+class CreateTableCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "CreateTable", {})
     .n("DynamoDBClient", "CreateTableCommand")
-    .sc(schemas_0.CreateTable$)
+    .sc(CreateTable$)
     .build() {
 }
 
-class DeleteBackupCommand extends client.Command
+class DeleteBackupCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "BackupArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DeleteBackup", {})
     .n("DynamoDBClient", "DeleteBackupCommand")
-    .sc(schemas_0.DeleteBackup$)
+    .sc(DeleteBackup$)
     .build() {
 }
 
-class DeleteItemCommand extends client.Command
+class DeleteItemCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DeleteItem", {})
     .n("DynamoDBClient", "DeleteItemCommand")
-    .sc(schemas_0.DeleteItem$)
+    .sc(DeleteItem$)
     .build() {
 }
 
-class DeleteResourcePolicyCommand extends client.Command
+class DeleteResourcePolicyCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "ResourceArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DeleteResourcePolicy", {})
     .n("DynamoDBClient", "DeleteResourcePolicyCommand")
-    .sc(schemas_0.DeleteResourcePolicy$)
+    .sc(DeleteResourcePolicy$)
     .build() {
 }
 
-class DeleteTableCommand extends client.Command
+class DeleteTableCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DeleteTable", {})
     .n("DynamoDBClient", "DeleteTableCommand")
-    .sc(schemas_0.DeleteTable$)
+    .sc(DeleteTable$)
     .build() {
 }
 
-class DescribeBackupCommand extends client.Command
+class DescribeBackupCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "BackupArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeBackup", {})
     .n("DynamoDBClient", "DescribeBackupCommand")
-    .sc(schemas_0.DescribeBackup$)
+    .sc(DescribeBackup$)
     .build() {
 }
 
-class DescribeContinuousBackupsCommand extends client.Command
+class DescribeContinuousBackupsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeContinuousBackups", {})
     .n("DynamoDBClient", "DescribeContinuousBackupsCommand")
-    .sc(schemas_0.DescribeContinuousBackups$)
+    .sc(DescribeContinuousBackups$)
     .build() {
 }
 
-class DescribeContributorInsightsCommand extends client.Command
+class DescribeContributorInsightsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeContributorInsights", {})
     .n("DynamoDBClient", "DescribeContributorInsightsCommand")
-    .sc(schemas_0.DescribeContributorInsights$)
+    .sc(DescribeContributorInsights$)
     .build() {
 }
 
-class DescribeExportCommand extends client.Command
+class DescribeExportCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "ExportArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeExport", {})
     .n("DynamoDBClient", "DescribeExportCommand")
-    .sc(schemas_0.DescribeExport$)
+    .sc(DescribeExport$)
     .build() {
 }
 
-class DescribeGlobalTableCommand extends client.Command
+class DescribeGlobalTableCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "GlobalTableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeGlobalTable", {})
     .n("DynamoDBClient", "DescribeGlobalTableCommand")
-    .sc(schemas_0.DescribeGlobalTable$)
+    .sc(DescribeGlobalTable$)
     .build() {
 }
 
-class DescribeGlobalTableSettingsCommand extends client.Command
+class DescribeGlobalTableSettingsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "GlobalTableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeGlobalTableSettings", {})
     .n("DynamoDBClient", "DescribeGlobalTableSettingsCommand")
-    .sc(schemas_0.DescribeGlobalTableSettings$)
+    .sc(DescribeGlobalTableSettings$)
     .build() {
 }
 
-class DescribeImportCommand extends client.Command
+class DescribeImportCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "ImportArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeImport", {})
     .n("DynamoDBClient", "DescribeImportCommand")
-    .sc(schemas_0.DescribeImport$)
+    .sc(DescribeImport$)
     .build() {
 }
 
-class DescribeKinesisStreamingDestinationCommand extends client.Command
+class DescribeKinesisStreamingDestinationCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeKinesisStreamingDestination", {})
     .n("DynamoDBClient", "DescribeKinesisStreamingDestinationCommand")
-    .sc(schemas_0.DescribeKinesisStreamingDestination$)
+    .sc(DescribeKinesisStreamingDestination$)
     .build() {
 }
 
-class DescribeLimitsCommand extends client.Command
+class DescribeLimitsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeLimits", {})
     .n("DynamoDBClient", "DescribeLimitsCommand")
-    .sc(schemas_0.DescribeLimits$)
+    .sc(DescribeLimits$)
     .build() {
 }
 
-class DescribeTableCommand extends client.Command
+class DescribeTableCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeTable", {})
     .n("DynamoDBClient", "DescribeTableCommand")
-    .sc(schemas_0.DescribeTable$)
+    .sc(DescribeTable$)
     .build() {
 }
 
-class DescribeTableReplicaAutoScalingCommand extends client.Command
+class DescribeTableReplicaAutoScalingCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeTableReplicaAutoScaling", {})
     .n("DynamoDBClient", "DescribeTableReplicaAutoScalingCommand")
-    .sc(schemas_0.DescribeTableReplicaAutoScaling$)
+    .sc(DescribeTableReplicaAutoScaling$)
     .build() {
 }
 
-class DescribeTimeToLiveCommand extends client.Command
+class DescribeTimeToLiveCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DescribeTimeToLive", {})
     .n("DynamoDBClient", "DescribeTimeToLiveCommand")
-    .sc(schemas_0.DescribeTimeToLive$)
+    .sc(DescribeTimeToLive$)
     .build() {
 }
 
-class DisableKinesisStreamingDestinationCommand extends client.Command
+class DisableKinesisStreamingDestinationCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "DisableKinesisStreamingDestination", {})
     .n("DynamoDBClient", "DisableKinesisStreamingDestinationCommand")
-    .sc(schemas_0.DisableKinesisStreamingDestination$)
+    .sc(DisableKinesisStreamingDestination$)
     .build() {
 }
 
-class EnableKinesisStreamingDestinationCommand extends client.Command
+class EnableKinesisStreamingDestinationCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "EnableKinesisStreamingDestination", {})
     .n("DynamoDBClient", "EnableKinesisStreamingDestinationCommand")
-    .sc(schemas_0.EnableKinesisStreamingDestination$)
+    .sc(EnableKinesisStreamingDestination$)
     .build() {
 }
 
-class ExecuteStatementCommand extends client.Command
+class ExecuteStatementCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ExecuteStatement", {})
     .n("DynamoDBClient", "ExecuteStatementCommand")
-    .sc(schemas_0.ExecuteStatement$)
+    .sc(ExecuteStatement$)
     .build() {
 }
 
-class ExecuteTransactionCommand extends client.Command
+class ExecuteTransactionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ExecuteTransaction", {})
     .n("DynamoDBClient", "ExecuteTransactionCommand")
-    .sc(schemas_0.ExecuteTransaction$)
+    .sc(ExecuteTransaction$)
     .build() {
 }
 
-class ExportTableToPointInTimeCommand extends client.Command
+class ExportTableToPointInTimeCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ExportTableToPointInTime", {})
     .n("DynamoDBClient", "ExportTableToPointInTimeCommand")
-    .sc(schemas_0.ExportTableToPointInTime$)
+    .sc(ExportTableToPointInTime$)
     .build() {
 }
 
-class GetItemCommand extends client.Command
+class GetItemCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "GetItem", {})
     .n("DynamoDBClient", "GetItemCommand")
-    .sc(schemas_0.GetItem$)
+    .sc(GetItem$)
     .build() {
 }
 
-class GetResourcePolicyCommand extends client.Command
+class GetResourcePolicyCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "ResourceArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "GetResourcePolicy", {})
     .n("DynamoDBClient", "GetResourcePolicyCommand")
-    .sc(schemas_0.GetResourcePolicy$)
+    .sc(GetResourcePolicy$)
     .build() {
 }
 
-class ImportTableCommand extends client.Command
+class ImportTableCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "operationContextParams", get: (input) => input?.TableCreationParameters?.TableName },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ImportTable", {})
     .n("DynamoDBClient", "ImportTableCommand")
-    .sc(schemas_0.ImportTable$)
+    .sc(ImportTable$)
     .build() {
 }
 
-class ListBackupsCommand extends client.Command
+class ListBackupsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ListBackups", {})
     .n("DynamoDBClient", "ListBackupsCommand")
-    .sc(schemas_0.ListBackups$)
+    .sc(ListBackups$)
     .build() {
 }
 
-class ListContributorInsightsCommand extends client.Command
+class ListContributorInsightsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ListContributorInsights", {})
     .n("DynamoDBClient", "ListContributorInsightsCommand")
-    .sc(schemas_0.ListContributorInsights$)
+    .sc(ListContributorInsights$)
     .build() {
 }
 
-class ListExportsCommand extends client.Command
+class ListExportsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ListExports", {})
     .n("DynamoDBClient", "ListExportsCommand")
-    .sc(schemas_0.ListExports$)
+    .sc(ListExports$)
     .build() {
 }
 
-class ListGlobalTablesCommand extends client.Command
+class ListGlobalTablesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ListGlobalTables", {})
     .n("DynamoDBClient", "ListGlobalTablesCommand")
-    .sc(schemas_0.ListGlobalTables$)
+    .sc(ListGlobalTables$)
     .build() {
 }
 
-class ListImportsCommand extends client.Command
+class ListImportsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ListImports", {})
     .n("DynamoDBClient", "ListImportsCommand")
-    .sc(schemas_0.ListImports$)
+    .sc(ListImports$)
     .build() {
 }
 
-class ListTablesCommand extends client.Command
+class ListTablesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ListTables", {})
     .n("DynamoDBClient", "ListTablesCommand")
-    .sc(schemas_0.ListTables$)
+    .sc(ListTables$)
     .build() {
 }
 
-class ListTagsOfResourceCommand extends client.Command
+class ListTagsOfResourceCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "ResourceArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "ListTagsOfResource", {})
     .n("DynamoDBClient", "ListTagsOfResourceCommand")
-    .sc(schemas_0.ListTagsOfResource$)
+    .sc(ListTagsOfResource$)
     .build() {
 }
 
-class PutItemCommand extends client.Command
+class PutItemCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "PutItem", {})
     .n("DynamoDBClient", "PutItemCommand")
-    .sc(schemas_0.PutItem$)
+    .sc(PutItem$)
     .build() {
 }
 
-class PutResourcePolicyCommand extends client.Command
+class PutResourcePolicyCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "ResourceArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "PutResourcePolicy", {})
     .n("DynamoDBClient", "PutResourcePolicyCommand")
-    .sc(schemas_0.PutResourcePolicy$)
+    .sc(PutResourcePolicy$)
     .build() {
 }
 
-class QueryCommand extends client.Command
+class QueryCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "Query", {})
     .n("DynamoDBClient", "QueryCommand")
-    .sc(schemas_0.Query$)
+    .sc(Query$)
     .build() {
 }
 
-class RestoreTableFromBackupCommand extends client.Command
+class RestoreTableFromBackupCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TargetTableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "RestoreTableFromBackup", {})
     .n("DynamoDBClient", "RestoreTableFromBackupCommand")
-    .sc(schemas_0.RestoreTableFromBackup$)
+    .sc(RestoreTableFromBackup$)
     .build() {
 }
 
-class RestoreTableToPointInTimeCommand extends client.Command
+class RestoreTableToPointInTimeCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TargetTableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "RestoreTableToPointInTime", {})
     .n("DynamoDBClient", "RestoreTableToPointInTimeCommand")
-    .sc(schemas_0.RestoreTableToPointInTime$)
+    .sc(RestoreTableToPointInTime$)
     .build() {
 }
 
-class ScanCommand extends client.Command
+class ScanCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "Scan", {})
     .n("DynamoDBClient", "ScanCommand")
-    .sc(schemas_0.Scan$)
+    .sc(Scan$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "ResourceArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "TagResource", {})
     .n("DynamoDBClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class TransactGetItemsCommand extends client.Command
+class TransactGetItemsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArnList: { type: "operationContextParams", get: (input) => input?.TransactItems?.map((obj) => obj?.Get?.TableName) },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "TransactGetItems", {})
     .n("DynamoDBClient", "TransactGetItemsCommand")
-    .sc(schemas_0.TransactGetItems$)
+    .sc(TransactGetItems$)
     .build() {
 }
 
-class TransactWriteItemsCommand extends client.Command
+class TransactWriteItemsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArnList: { type: "operationContextParams", get: (input) => input?.TransactItems?.map((obj) => [obj?.ConditionCheck?.TableName, obj?.Put?.TableName, obj?.Delete?.TableName, obj?.Update?.TableName].filter((i) => i)).flat() },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "TransactWriteItems", {})
     .n("DynamoDBClient", "TransactWriteItemsCommand")
-    .sc(schemas_0.TransactWriteItems$)
+    .sc(TransactWriteItems$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "ResourceArn" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UntagResource", {})
     .n("DynamoDBClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateContinuousBackupsCommand extends client.Command
+class UpdateContinuousBackupsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateContinuousBackups", {})
     .n("DynamoDBClient", "UpdateContinuousBackupsCommand")
-    .sc(schemas_0.UpdateContinuousBackups$)
+    .sc(UpdateContinuousBackups$)
     .build() {
 }
 
-class UpdateContributorInsightsCommand extends client.Command
+class UpdateContributorInsightsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateContributorInsights", {})
     .n("DynamoDBClient", "UpdateContributorInsightsCommand")
-    .sc(schemas_0.UpdateContributorInsights$)
+    .sc(UpdateContributorInsights$)
     .build() {
 }
 
-class UpdateGlobalTableCommand extends client.Command
+class UpdateGlobalTableCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "GlobalTableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateGlobalTable", {})
     .n("DynamoDBClient", "UpdateGlobalTableCommand")
-    .sc(schemas_0.UpdateGlobalTable$)
+    .sc(UpdateGlobalTable$)
     .build() {
 }
 
-class UpdateGlobalTableSettingsCommand extends client.Command
+class UpdateGlobalTableSettingsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "GlobalTableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateGlobalTableSettings", {})
     .n("DynamoDBClient", "UpdateGlobalTableSettingsCommand")
-    .sc(schemas_0.UpdateGlobalTableSettings$)
+    .sc(UpdateGlobalTableSettings$)
     .build() {
 }
 
-class UpdateItemCommand extends client.Command
+class UpdateItemCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateItem", {})
     .n("DynamoDBClient", "UpdateItemCommand")
-    .sc(schemas_0.UpdateItem$)
+    .sc(UpdateItem$)
     .build() {
 }
 
-class UpdateKinesisStreamingDestinationCommand extends client.Command
+class UpdateKinesisStreamingDestinationCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateKinesisStreamingDestination", {})
     .n("DynamoDBClient", "UpdateKinesisStreamingDestinationCommand")
-    .sc(schemas_0.UpdateKinesisStreamingDestination$)
+    .sc(UpdateKinesisStreamingDestination$)
     .build() {
 }
 
-class UpdateTableCommand extends client.Command
+class UpdateTableCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateTable", {})
     .n("DynamoDBClient", "UpdateTableCommand")
-    .sc(schemas_0.UpdateTable$)
+    .sc(UpdateTable$)
     .build() {
 }
 
-class UpdateTableReplicaAutoScalingCommand extends client.Command
+class UpdateTableReplicaAutoScalingCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateTableReplicaAutoScaling", {})
     .n("DynamoDBClient", "UpdateTableReplicaAutoScalingCommand")
-    .sc(schemas_0.UpdateTableReplicaAutoScaling$)
+    .sc(UpdateTableReplicaAutoScaling$)
     .build() {
 }
 
-class UpdateTimeToLiveCommand extends client.Command
+class UpdateTimeToLiveCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     ResourceArn: { type: "contextParams", name: "TableName" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("DynamoDB_20120810", "UpdateTimeToLive", {})
     .n("DynamoDBClient", "UpdateTimeToLiveCommand")
-    .sc(schemas_0.UpdateTimeToLive$)
+    .sc(UpdateTimeToLive$)
     .build() {
 }
 
-const paginateListContributorInsights = core.createPaginator(DynamoDBClient, ListContributorInsightsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListContributorInsights = createPaginator(DynamoDBClient, ListContributorInsightsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListExports = core.createPaginator(DynamoDBClient, ListExportsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListExports = createPaginator(DynamoDBClient, ListExportsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListImports = core.createPaginator(DynamoDBClient, ListImportsCommand, "NextToken", "NextToken", "PageSize");
+const paginateListImports = createPaginator(DynamoDBClient, ListImportsCommand, "NextToken", "NextToken", "PageSize");
 
-const paginateListTables = core.createPaginator(DynamoDBClient, ListTablesCommand, "ExclusiveStartTableName", "LastEvaluatedTableName", "Limit");
+const paginateListTables = createPaginator(DynamoDBClient, ListTablesCommand, "ExclusiveStartTableName", "LastEvaluatedTableName", "Limit");
 
-const paginateQuery = core.createPaginator(DynamoDBClient, QueryCommand, "ExclusiveStartKey", "LastEvaluatedKey", "Limit");
+const paginateQuery = createPaginator(DynamoDBClient, QueryCommand, "ExclusiveStartKey", "LastEvaluatedKey", "Limit");
 
-const paginateScan = core.createPaginator(DynamoDBClient, ScanCommand, "ExclusiveStartKey", "LastEvaluatedKey", "Limit");
+const paginateScan = createPaginator(DynamoDBClient, ScanCommand, "ExclusiveStartKey", "LastEvaluatedKey", "Limit");
 
-const checkState$5 = async (client$1, input) => {
+const checkState$5 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeContributorInsightsCommand(input));
+        let result = await client.send(new DescribeContributorInsightsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.ContributorInsightsStatus;
             };
             if (returnComparator() === "ENABLED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -979,7 +982,7 @@ const checkState$5 = async (client$1, input) => {
                 return result.ContributorInsightsStatus;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -987,29 +990,29 @@ const checkState$5 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForContributorInsightsEnabled = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilContributorInsightsEnabled = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return checkExceptions(result);
 };
 
-const checkState$4 = async (client$1, input) => {
+const checkState$4 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeExportCommand(input));
+        let result = await client.send(new DescribeExportCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.ExportDescription.ExportStatus;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1018,7 +1021,7 @@ const checkState$4 = async (client$1, input) => {
                 return result.ExportDescription.ExportStatus;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1026,29 +1029,29 @@ const checkState$4 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForExportCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilExportCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return checkExceptions(result);
 };
 
-const checkState$3 = async (client$1, input) => {
+const checkState$3 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeImportCommand(input));
+        let result = await client.send(new DescribeImportCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.ImportTableDescription.ImportStatus;
             };
             if (returnComparator() === "COMPLETED") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1057,7 +1060,7 @@ const checkState$3 = async (client$1, input) => {
                 return result.ImportTableDescription.ImportStatus;
             };
             if (returnComparator() === "FAILED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1066,7 +1069,7 @@ const checkState$3 = async (client$1, input) => {
                 return result.ImportTableDescription.ImportStatus;
             };
             if (returnComparator() === "CANCELLED") {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1074,22 +1077,22 @@ const checkState$3 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForImportCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilImportCompleted = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return checkExceptions(result);
 };
 
-const checkState$2 = async (client$1, input) => {
+const checkState$2 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeKinesisStreamingDestinationCommand(input));
+        let result = await client.send(new DescribeKinesisStreamingDestinationCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -1101,7 +1104,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "ACTIVE") {
-                    return { state: client.WaiterState.SUCCESS, reason };
+                    return { state: WaiterState.SUCCESS, reason };
                 }
             }
         }
@@ -1114,7 +1117,7 @@ const checkState$2 = async (client$1, input) => {
                 return ((result.KinesisDataStreamDestinations.length > 0) && (filterRes_2.length == result.KinesisDataStreamDestinations.length));
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.FAILURE, reason };
+                return { state: WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -1122,29 +1125,29 @@ const checkState$2 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForKinesisStreamingDestinationActive = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilKinesisStreamingDestinationActive = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return checkExceptions(result);
 };
 
-const checkState$1 = async (client$1, input) => {
+const checkState$1 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeTableCommand(input));
+        let result = await client.send(new DescribeTableCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.Table.TableStatus;
             };
             if (returnComparator() === "ACTIVE") {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -1152,43 +1155,43 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: client.WaiterState.RETRY, reason };
+            return { state: WaiterState.RETRY, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTableExists = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilTableExists = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return checkExceptions(result);
 };
 
-const checkState = async (client$1, input) => {
+const checkState = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeTableCommand(input));
+        let result = await client.send(new DescribeTableCommand(input));
         reason = result;
     }
     catch (exception) {
         reason = exception;
         if (exception.name === "ResourceNotFoundException") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTableNotExists = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilTableNotExists = async (params, input) => {
     const serviceDefaults = { minDelay: 20, maxDelay: 120 };
-    const result = await client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
-    return client.checkExceptions(result);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
 };
 
 const commands = {
@@ -1268,7 +1271,7 @@ const waiters = {
 };
 class DynamoDB extends DynamoDBClient {
 }
-client.createAggregatedClient(commands, DynamoDB, { paginators, waiters });
+createAggregatedClient(commands, DynamoDB, { paginators, waiters });
 
 const ApproximateCreationDateTimePrecision = {
     MICROSECOND: "MICROSECOND",
@@ -1516,9 +1519,6 @@ const Select = {
     SPECIFIC_ATTRIBUTES: "SPECIFIC_ATTRIBUTES",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.DynamoDBServiceException = DynamoDBServiceException.DynamoDBServiceException;
 exports.ApproximateCreationDateTimePrecision = ApproximateCreationDateTimePrecision;
 exports.AttributeAction = AttributeAction;
 exports.BackupStatus = BackupStatus;
@@ -1639,23 +1639,3 @@ exports.waitUntilImportCompleted = waitUntilImportCompleted;
 exports.waitUntilKinesisStreamingDestinationActive = waitUntilKinesisStreamingDestinationActive;
 exports.waitUntilTableExists = waitUntilTableExists;
 exports.waitUntilTableNotExists = waitUntilTableNotExists;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});