@aws-sdk/client-lakeformation 3.1068.0 → 3.1070.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-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 runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var LakeFormationServiceException = require('./models/LakeFormationServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultLakeFormationHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { AddLFTagsToResource$, AssumeDecoratedRoleWithSAML$, BatchGrantPermissions$, BatchRevokePermissions$, CancelTransaction$, CommitTransaction$, CreateDataCellsFilter$, CreateLakeFormationIdentityCenterConfiguration$, CreateLakeFormationOptIn$, CreateLFTag$, CreateLFTagExpression$, DeleteDataCellsFilter$, DeleteLakeFormationIdentityCenterConfiguration$, DeleteLakeFormationOptIn$, DeleteLFTag$, DeleteLFTagExpression$, DeleteObjectsOnCancel$, DeregisterResource$, DescribeLakeFormationIdentityCenterConfiguration$, DescribeResource$, DescribeTransaction$, ExtendTransaction$, GetDataCellsFilter$, GetDataLakePrincipal$, GetDataLakeSettings$, GetEffectivePermissionsForPath$, GetLFTag$, GetLFTagExpression$, GetQueryState$, GetQueryStatistics$, GetResourceLFTags$, GetTableObjects$, GetTemporaryDataLocationCredentials$, GetTemporaryGluePartitionCredentials$, GetTemporaryGlueTableCredentials$, GetWorkUnitResults$, GetWorkUnits$, GrantPermissions$, ListDataCellsFilter$, ListLakeFormationOptIns$, ListLFTagExpressions$, ListLFTags$, ListPermissions$, ListResources$, ListTableStorageOptimizers$, ListTransactions$, PutDataLakeSettings$, RegisterResource$, RemoveLFTagsFromResource$, RevokePermissions$, SearchDatabasesByLFTags$, SearchTablesByLFTags$, StartQueryPlanning$, StartTransaction$, UpdateDataCellsFilter$, UpdateLakeFormationIdentityCenterConfiguration$, UpdateLFTag$, UpdateLFTagExpression$, UpdateResource$, UpdateTableObjects$, UpdateTableStorageOptimizer$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { LakeFormationServiceException } = require("./models/LakeFormationServiceException");
+exports.LakeFormationServiceException = LakeFormationServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,803 +71,803 @@ 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 LakeFormationClient extends client.Client {
+class LakeFormationClient 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 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
-        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.defaultLakeFormationHttpAuthSchemeParametersProvider,
-            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: defaultLakeFormationHttpAuthSchemeParametersProvider,
+            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 AddLFTagsToResourceCommand extends client.Command
+class AddLFTagsToResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "AddLFTagsToResource", {})
     .n("LakeFormationClient", "AddLFTagsToResourceCommand")
-    .sc(schemas_0.AddLFTagsToResource$)
+    .sc(AddLFTagsToResource$)
     .build() {
 }
 
-class AssumeDecoratedRoleWithSAMLCommand extends client.Command
+class AssumeDecoratedRoleWithSAMLCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "AssumeDecoratedRoleWithSAML", {})
     .n("LakeFormationClient", "AssumeDecoratedRoleWithSAMLCommand")
-    .sc(schemas_0.AssumeDecoratedRoleWithSAML$)
+    .sc(AssumeDecoratedRoleWithSAML$)
     .build() {
 }
 
-class BatchGrantPermissionsCommand extends client.Command
+class BatchGrantPermissionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "BatchGrantPermissions", {})
     .n("LakeFormationClient", "BatchGrantPermissionsCommand")
-    .sc(schemas_0.BatchGrantPermissions$)
+    .sc(BatchGrantPermissions$)
     .build() {
 }
 
-class BatchRevokePermissionsCommand extends client.Command
+class BatchRevokePermissionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "BatchRevokePermissions", {})
     .n("LakeFormationClient", "BatchRevokePermissionsCommand")
-    .sc(schemas_0.BatchRevokePermissions$)
+    .sc(BatchRevokePermissions$)
     .build() {
 }
 
-class CancelTransactionCommand extends client.Command
+class CancelTransactionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "CancelTransaction", {})
     .n("LakeFormationClient", "CancelTransactionCommand")
-    .sc(schemas_0.CancelTransaction$)
+    .sc(CancelTransaction$)
     .build() {
 }
 
-class CommitTransactionCommand extends client.Command
+class CommitTransactionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "CommitTransaction", {})
     .n("LakeFormationClient", "CommitTransactionCommand")
-    .sc(schemas_0.CommitTransaction$)
+    .sc(CommitTransaction$)
     .build() {
 }
 
-class CreateDataCellsFilterCommand extends client.Command
+class CreateDataCellsFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "CreateDataCellsFilter", {})
     .n("LakeFormationClient", "CreateDataCellsFilterCommand")
-    .sc(schemas_0.CreateDataCellsFilter$)
+    .sc(CreateDataCellsFilter$)
     .build() {
 }
 
-class CreateLakeFormationIdentityCenterConfigurationCommand extends client.Command
+class CreateLakeFormationIdentityCenterConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "CreateLakeFormationIdentityCenterConfiguration", {})
     .n("LakeFormationClient", "CreateLakeFormationIdentityCenterConfigurationCommand")
-    .sc(schemas_0.CreateLakeFormationIdentityCenterConfiguration$)
+    .sc(CreateLakeFormationIdentityCenterConfiguration$)
     .build() {
 }
 
-class CreateLakeFormationOptInCommand extends client.Command
+class CreateLakeFormationOptInCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "CreateLakeFormationOptIn", {})
     .n("LakeFormationClient", "CreateLakeFormationOptInCommand")
-    .sc(schemas_0.CreateLakeFormationOptIn$)
+    .sc(CreateLakeFormationOptIn$)
     .build() {
 }
 
-class CreateLFTagCommand extends client.Command
+class CreateLFTagCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "CreateLFTag", {})
     .n("LakeFormationClient", "CreateLFTagCommand")
-    .sc(schemas_0.CreateLFTag$)
+    .sc(CreateLFTag$)
     .build() {
 }
 
-class CreateLFTagExpressionCommand extends client.Command
+class CreateLFTagExpressionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "CreateLFTagExpression", {})
     .n("LakeFormationClient", "CreateLFTagExpressionCommand")
-    .sc(schemas_0.CreateLFTagExpression$)
+    .sc(CreateLFTagExpression$)
     .build() {
 }
 
-class DeleteDataCellsFilterCommand extends client.Command
+class DeleteDataCellsFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DeleteDataCellsFilter", {})
     .n("LakeFormationClient", "DeleteDataCellsFilterCommand")
-    .sc(schemas_0.DeleteDataCellsFilter$)
+    .sc(DeleteDataCellsFilter$)
     .build() {
 }
 
-class DeleteLakeFormationIdentityCenterConfigurationCommand extends client.Command
+class DeleteLakeFormationIdentityCenterConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DeleteLakeFormationIdentityCenterConfiguration", {})
     .n("LakeFormationClient", "DeleteLakeFormationIdentityCenterConfigurationCommand")
-    .sc(schemas_0.DeleteLakeFormationIdentityCenterConfiguration$)
+    .sc(DeleteLakeFormationIdentityCenterConfiguration$)
     .build() {
 }
 
-class DeleteLakeFormationOptInCommand extends client.Command
+class DeleteLakeFormationOptInCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DeleteLakeFormationOptIn", {})
     .n("LakeFormationClient", "DeleteLakeFormationOptInCommand")
-    .sc(schemas_0.DeleteLakeFormationOptIn$)
+    .sc(DeleteLakeFormationOptIn$)
     .build() {
 }
 
-class DeleteLFTagCommand extends client.Command
+class DeleteLFTagCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DeleteLFTag", {})
     .n("LakeFormationClient", "DeleteLFTagCommand")
-    .sc(schemas_0.DeleteLFTag$)
+    .sc(DeleteLFTag$)
     .build() {
 }
 
-class DeleteLFTagExpressionCommand extends client.Command
+class DeleteLFTagExpressionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DeleteLFTagExpression", {})
     .n("LakeFormationClient", "DeleteLFTagExpressionCommand")
-    .sc(schemas_0.DeleteLFTagExpression$)
+    .sc(DeleteLFTagExpression$)
     .build() {
 }
 
-class DeleteObjectsOnCancelCommand extends client.Command
+class DeleteObjectsOnCancelCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DeleteObjectsOnCancel", {})
     .n("LakeFormationClient", "DeleteObjectsOnCancelCommand")
-    .sc(schemas_0.DeleteObjectsOnCancel$)
+    .sc(DeleteObjectsOnCancel$)
     .build() {
 }
 
-class DeregisterResourceCommand extends client.Command
+class DeregisterResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DeregisterResource", {})
     .n("LakeFormationClient", "DeregisterResourceCommand")
-    .sc(schemas_0.DeregisterResource$)
+    .sc(DeregisterResource$)
     .build() {
 }
 
-class DescribeLakeFormationIdentityCenterConfigurationCommand extends client.Command
+class DescribeLakeFormationIdentityCenterConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DescribeLakeFormationIdentityCenterConfiguration", {})
     .n("LakeFormationClient", "DescribeLakeFormationIdentityCenterConfigurationCommand")
-    .sc(schemas_0.DescribeLakeFormationIdentityCenterConfiguration$)
+    .sc(DescribeLakeFormationIdentityCenterConfiguration$)
     .build() {
 }
 
-class DescribeResourceCommand extends client.Command
+class DescribeResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DescribeResource", {})
     .n("LakeFormationClient", "DescribeResourceCommand")
-    .sc(schemas_0.DescribeResource$)
+    .sc(DescribeResource$)
     .build() {
 }
 
-class DescribeTransactionCommand extends client.Command
+class DescribeTransactionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "DescribeTransaction", {})
     .n("LakeFormationClient", "DescribeTransactionCommand")
-    .sc(schemas_0.DescribeTransaction$)
+    .sc(DescribeTransaction$)
     .build() {
 }
 
-class ExtendTransactionCommand extends client.Command
+class ExtendTransactionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ExtendTransaction", {})
     .n("LakeFormationClient", "ExtendTransactionCommand")
-    .sc(schemas_0.ExtendTransaction$)
+    .sc(ExtendTransaction$)
     .build() {
 }
 
-class GetDataCellsFilterCommand extends client.Command
+class GetDataCellsFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetDataCellsFilter", {})
     .n("LakeFormationClient", "GetDataCellsFilterCommand")
-    .sc(schemas_0.GetDataCellsFilter$)
+    .sc(GetDataCellsFilter$)
     .build() {
 }
 
-class GetDataLakePrincipalCommand extends client.Command
+class GetDataLakePrincipalCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetDataLakePrincipal", {})
     .n("LakeFormationClient", "GetDataLakePrincipalCommand")
-    .sc(schemas_0.GetDataLakePrincipal$)
+    .sc(GetDataLakePrincipal$)
     .build() {
 }
 
-class GetDataLakeSettingsCommand extends client.Command
+class GetDataLakeSettingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetDataLakeSettings", {})
     .n("LakeFormationClient", "GetDataLakeSettingsCommand")
-    .sc(schemas_0.GetDataLakeSettings$)
+    .sc(GetDataLakeSettings$)
     .build() {
 }
 
-class GetEffectivePermissionsForPathCommand extends client.Command
+class GetEffectivePermissionsForPathCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetEffectivePermissionsForPath", {})
     .n("LakeFormationClient", "GetEffectivePermissionsForPathCommand")
-    .sc(schemas_0.GetEffectivePermissionsForPath$)
+    .sc(GetEffectivePermissionsForPath$)
     .build() {
 }
 
-class GetLFTagCommand extends client.Command
+class GetLFTagCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetLFTag", {})
     .n("LakeFormationClient", "GetLFTagCommand")
-    .sc(schemas_0.GetLFTag$)
+    .sc(GetLFTag$)
     .build() {
 }
 
-class GetLFTagExpressionCommand extends client.Command
+class GetLFTagExpressionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetLFTagExpression", {})
     .n("LakeFormationClient", "GetLFTagExpressionCommand")
-    .sc(schemas_0.GetLFTagExpression$)
+    .sc(GetLFTagExpression$)
     .build() {
 }
 
-class GetQueryStateCommand extends client.Command
+class GetQueryStateCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetQueryState", {})
     .n("LakeFormationClient", "GetQueryStateCommand")
-    .sc(schemas_0.GetQueryState$)
+    .sc(GetQueryState$)
     .build() {
 }
 
-class GetQueryStatisticsCommand extends client.Command
+class GetQueryStatisticsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetQueryStatistics", {})
     .n("LakeFormationClient", "GetQueryStatisticsCommand")
-    .sc(schemas_0.GetQueryStatistics$)
+    .sc(GetQueryStatistics$)
     .build() {
 }
 
-class GetResourceLFTagsCommand extends client.Command
+class GetResourceLFTagsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetResourceLFTags", {})
     .n("LakeFormationClient", "GetResourceLFTagsCommand")
-    .sc(schemas_0.GetResourceLFTags$)
+    .sc(GetResourceLFTags$)
     .build() {
 }
 
-class GetTableObjectsCommand extends client.Command
+class GetTableObjectsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetTableObjects", {})
     .n("LakeFormationClient", "GetTableObjectsCommand")
-    .sc(schemas_0.GetTableObjects$)
+    .sc(GetTableObjects$)
     .build() {
 }
 
-class GetTemporaryDataLocationCredentialsCommand extends client.Command
+class GetTemporaryDataLocationCredentialsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetTemporaryDataLocationCredentials", {})
     .n("LakeFormationClient", "GetTemporaryDataLocationCredentialsCommand")
-    .sc(schemas_0.GetTemporaryDataLocationCredentials$)
+    .sc(GetTemporaryDataLocationCredentials$)
     .build() {
 }
 
-class GetTemporaryGluePartitionCredentialsCommand extends client.Command
+class GetTemporaryGluePartitionCredentialsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetTemporaryGluePartitionCredentials", {})
     .n("LakeFormationClient", "GetTemporaryGluePartitionCredentialsCommand")
-    .sc(schemas_0.GetTemporaryGluePartitionCredentials$)
+    .sc(GetTemporaryGluePartitionCredentials$)
     .build() {
 }
 
-class GetTemporaryGlueTableCredentialsCommand extends client.Command
+class GetTemporaryGlueTableCredentialsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetTemporaryGlueTableCredentials", {})
     .n("LakeFormationClient", "GetTemporaryGlueTableCredentialsCommand")
-    .sc(schemas_0.GetTemporaryGlueTableCredentials$)
+    .sc(GetTemporaryGlueTableCredentials$)
     .build() {
 }
 
-class GetWorkUnitResultsCommand extends client.Command
+class GetWorkUnitResultsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetWorkUnitResults", {})
     .n("LakeFormationClient", "GetWorkUnitResultsCommand")
-    .sc(schemas_0.GetWorkUnitResults$)
+    .sc(GetWorkUnitResults$)
     .build() {
 }
 
-class GetWorkUnitsCommand extends client.Command
+class GetWorkUnitsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GetWorkUnits", {})
     .n("LakeFormationClient", "GetWorkUnitsCommand")
-    .sc(schemas_0.GetWorkUnits$)
+    .sc(GetWorkUnits$)
     .build() {
 }
 
-class GrantPermissionsCommand extends client.Command
+class GrantPermissionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "GrantPermissions", {})
     .n("LakeFormationClient", "GrantPermissionsCommand")
-    .sc(schemas_0.GrantPermissions$)
+    .sc(GrantPermissions$)
     .build() {
 }
 
-class ListDataCellsFilterCommand extends client.Command
+class ListDataCellsFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ListDataCellsFilter", {})
     .n("LakeFormationClient", "ListDataCellsFilterCommand")
-    .sc(schemas_0.ListDataCellsFilter$)
+    .sc(ListDataCellsFilter$)
     .build() {
 }
 
-class ListLakeFormationOptInsCommand extends client.Command
+class ListLakeFormationOptInsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ListLakeFormationOptIns", {})
     .n("LakeFormationClient", "ListLakeFormationOptInsCommand")
-    .sc(schemas_0.ListLakeFormationOptIns$)
+    .sc(ListLakeFormationOptIns$)
     .build() {
 }
 
-class ListLFTagExpressionsCommand extends client.Command
+class ListLFTagExpressionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ListLFTagExpressions", {})
     .n("LakeFormationClient", "ListLFTagExpressionsCommand")
-    .sc(schemas_0.ListLFTagExpressions$)
+    .sc(ListLFTagExpressions$)
     .build() {
 }
 
-class ListLFTagsCommand extends client.Command
+class ListLFTagsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ListLFTags", {})
     .n("LakeFormationClient", "ListLFTagsCommand")
-    .sc(schemas_0.ListLFTags$)
+    .sc(ListLFTags$)
     .build() {
 }
 
-class ListPermissionsCommand extends client.Command
+class ListPermissionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ListPermissions", {})
     .n("LakeFormationClient", "ListPermissionsCommand")
-    .sc(schemas_0.ListPermissions$)
+    .sc(ListPermissions$)
     .build() {
 }
 
-class ListResourcesCommand extends client.Command
+class ListResourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ListResources", {})
     .n("LakeFormationClient", "ListResourcesCommand")
-    .sc(schemas_0.ListResources$)
+    .sc(ListResources$)
     .build() {
 }
 
-class ListTableStorageOptimizersCommand extends client.Command
+class ListTableStorageOptimizersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ListTableStorageOptimizers", {})
     .n("LakeFormationClient", "ListTableStorageOptimizersCommand")
-    .sc(schemas_0.ListTableStorageOptimizers$)
+    .sc(ListTableStorageOptimizers$)
     .build() {
 }
 
-class ListTransactionsCommand extends client.Command
+class ListTransactionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "ListTransactions", {})
     .n("LakeFormationClient", "ListTransactionsCommand")
-    .sc(schemas_0.ListTransactions$)
+    .sc(ListTransactions$)
     .build() {
 }
 
-class PutDataLakeSettingsCommand extends client.Command
+class PutDataLakeSettingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "PutDataLakeSettings", {})
     .n("LakeFormationClient", "PutDataLakeSettingsCommand")
-    .sc(schemas_0.PutDataLakeSettings$)
+    .sc(PutDataLakeSettings$)
     .build() {
 }
 
-class RegisterResourceCommand extends client.Command
+class RegisterResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "RegisterResource", {})
     .n("LakeFormationClient", "RegisterResourceCommand")
-    .sc(schemas_0.RegisterResource$)
+    .sc(RegisterResource$)
     .build() {
 }
 
-class RemoveLFTagsFromResourceCommand extends client.Command
+class RemoveLFTagsFromResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "RemoveLFTagsFromResource", {})
     .n("LakeFormationClient", "RemoveLFTagsFromResourceCommand")
-    .sc(schemas_0.RemoveLFTagsFromResource$)
+    .sc(RemoveLFTagsFromResource$)
     .build() {
 }
 
-class RevokePermissionsCommand extends client.Command
+class RevokePermissionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "RevokePermissions", {})
     .n("LakeFormationClient", "RevokePermissionsCommand")
-    .sc(schemas_0.RevokePermissions$)
+    .sc(RevokePermissions$)
     .build() {
 }
 
-class SearchDatabasesByLFTagsCommand extends client.Command
+class SearchDatabasesByLFTagsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "SearchDatabasesByLFTags", {})
     .n("LakeFormationClient", "SearchDatabasesByLFTagsCommand")
-    .sc(schemas_0.SearchDatabasesByLFTags$)
+    .sc(SearchDatabasesByLFTags$)
     .build() {
 }
 
-class SearchTablesByLFTagsCommand extends client.Command
+class SearchTablesByLFTagsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "SearchTablesByLFTags", {})
     .n("LakeFormationClient", "SearchTablesByLFTagsCommand")
-    .sc(schemas_0.SearchTablesByLFTags$)
+    .sc(SearchTablesByLFTags$)
     .build() {
 }
 
-class StartQueryPlanningCommand extends client.Command
+class StartQueryPlanningCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "StartQueryPlanning", {})
     .n("LakeFormationClient", "StartQueryPlanningCommand")
-    .sc(schemas_0.StartQueryPlanning$)
+    .sc(StartQueryPlanning$)
     .build() {
 }
 
-class StartTransactionCommand extends client.Command
+class StartTransactionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "StartTransaction", {})
     .n("LakeFormationClient", "StartTransactionCommand")
-    .sc(schemas_0.StartTransaction$)
+    .sc(StartTransaction$)
     .build() {
 }
 
-class UpdateDataCellsFilterCommand extends client.Command
+class UpdateDataCellsFilterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "UpdateDataCellsFilter", {})
     .n("LakeFormationClient", "UpdateDataCellsFilterCommand")
-    .sc(schemas_0.UpdateDataCellsFilter$)
+    .sc(UpdateDataCellsFilter$)
     .build() {
 }
 
-class UpdateLakeFormationIdentityCenterConfigurationCommand extends client.Command
+class UpdateLakeFormationIdentityCenterConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "UpdateLakeFormationIdentityCenterConfiguration", {})
     .n("LakeFormationClient", "UpdateLakeFormationIdentityCenterConfigurationCommand")
-    .sc(schemas_0.UpdateLakeFormationIdentityCenterConfiguration$)
+    .sc(UpdateLakeFormationIdentityCenterConfiguration$)
     .build() {
 }
 
-class UpdateLFTagCommand extends client.Command
+class UpdateLFTagCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "UpdateLFTag", {})
     .n("LakeFormationClient", "UpdateLFTagCommand")
-    .sc(schemas_0.UpdateLFTag$)
+    .sc(UpdateLFTag$)
     .build() {
 }
 
-class UpdateLFTagExpressionCommand extends client.Command
+class UpdateLFTagExpressionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "UpdateLFTagExpression", {})
     .n("LakeFormationClient", "UpdateLFTagExpressionCommand")
-    .sc(schemas_0.UpdateLFTagExpression$)
+    .sc(UpdateLFTagExpression$)
     .build() {
 }
 
-class UpdateResourceCommand extends client.Command
+class UpdateResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "UpdateResource", {})
     .n("LakeFormationClient", "UpdateResourceCommand")
-    .sc(schemas_0.UpdateResource$)
+    .sc(UpdateResource$)
     .build() {
 }
 
-class UpdateTableObjectsCommand extends client.Command
+class UpdateTableObjectsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "UpdateTableObjects", {})
     .n("LakeFormationClient", "UpdateTableObjectsCommand")
-    .sc(schemas_0.UpdateTableObjects$)
+    .sc(UpdateTableObjects$)
     .build() {
 }
 
-class UpdateTableStorageOptimizerCommand extends client.Command
+class UpdateTableStorageOptimizerCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSLakeFormation", "UpdateTableStorageOptimizer", {})
     .n("LakeFormationClient", "UpdateTableStorageOptimizerCommand")
-    .sc(schemas_0.UpdateTableStorageOptimizer$)
+    .sc(UpdateTableStorageOptimizer$)
     .build() {
 }
 
-const paginateGetEffectivePermissionsForPath = core.createPaginator(LakeFormationClient, GetEffectivePermissionsForPathCommand, "NextToken", "NextToken", "MaxResults");
+const paginateGetEffectivePermissionsForPath = createPaginator(LakeFormationClient, GetEffectivePermissionsForPathCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateGetTableObjects = core.createPaginator(LakeFormationClient, GetTableObjectsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateGetTableObjects = createPaginator(LakeFormationClient, GetTableObjectsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateGetWorkUnits = core.createPaginator(LakeFormationClient, GetWorkUnitsCommand, "NextToken", "NextToken", "PageSize");
+const paginateGetWorkUnits = createPaginator(LakeFormationClient, GetWorkUnitsCommand, "NextToken", "NextToken", "PageSize");
 
-const paginateListDataCellsFilter = core.createPaginator(LakeFormationClient, ListDataCellsFilterCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDataCellsFilter = createPaginator(LakeFormationClient, ListDataCellsFilterCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListLakeFormationOptIns = core.createPaginator(LakeFormationClient, ListLakeFormationOptInsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListLakeFormationOptIns = createPaginator(LakeFormationClient, ListLakeFormationOptInsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListLFTagExpressions = core.createPaginator(LakeFormationClient, ListLFTagExpressionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListLFTagExpressions = createPaginator(LakeFormationClient, ListLFTagExpressionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListLFTags = core.createPaginator(LakeFormationClient, ListLFTagsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListLFTags = createPaginator(LakeFormationClient, ListLFTagsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListPermissions = core.createPaginator(LakeFormationClient, ListPermissionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListPermissions = createPaginator(LakeFormationClient, ListPermissionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListResources = core.createPaginator(LakeFormationClient, ListResourcesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListResources = createPaginator(LakeFormationClient, ListResourcesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTableStorageOptimizers = core.createPaginator(LakeFormationClient, ListTableStorageOptimizersCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTableStorageOptimizers = createPaginator(LakeFormationClient, ListTableStorageOptimizersCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTransactions = core.createPaginator(LakeFormationClient, ListTransactionsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTransactions = createPaginator(LakeFormationClient, ListTransactionsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateSearchDatabasesByLFTags = core.createPaginator(LakeFormationClient, SearchDatabasesByLFTagsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateSearchDatabasesByLFTags = createPaginator(LakeFormationClient, SearchDatabasesByLFTagsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateSearchTablesByLFTags = core.createPaginator(LakeFormationClient, SearchTablesByLFTagsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateSearchTablesByLFTags = createPaginator(LakeFormationClient, SearchTablesByLFTagsCommand, "NextToken", "NextToken", "MaxResults");
 
 const commands = {
     AddLFTagsToResourceCommand,
@@ -946,7 +949,7 @@ const paginators = {
 };
 class LakeFormation extends LakeFormationClient {
 }
-client.createAggregatedClient(commands, LakeFormation, { paginators });
+createAggregatedClient(commands, LakeFormation, { paginators });
 
 const ResourceType = {
     DATABASE: "DATABASE",
@@ -1060,9 +1063,6 @@ const TransactionType = {
     READ_ONLY: "READ_ONLY",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.LakeFormationServiceException = LakeFormationServiceException.LakeFormationServiceException;
 exports.AddLFTagsToResourceCommand = AddLFTagsToResourceCommand;
 exports.ApplicationStatus = ApplicationStatus;
 exports.AssumeDecoratedRoleWithSAMLCommand = AssumeDecoratedRoleWithSAMLCommand;
@@ -1156,23 +1156,3 @@ exports.paginateListTableStorageOptimizers = paginateListTableStorageOptimizers;
 exports.paginateListTransactions = paginateListTransactions;
 exports.paginateSearchDatabasesByLFTags = paginateSearchDatabasesByLFTags;
 exports.paginateSearchTablesByLFTags = paginateSearchTablesByLFTags;
-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];
-});