@aws-sdk/client-lakeformation 3.183.0 → 3.185.0

package/dist-es/LakeFormationClient.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
@@ -8,26 +9,31 @@ import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-sig
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
 import { Client as __Client, } from "@aws-sdk/smithy-client";
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
-export class LakeFormationClient extends __Client {
-    constructor(configuration) {
-        const _config_0 = __getRuntimeConfig(configuration);
-        const _config_1 = resolveRegionConfig(_config_0);
-        const _config_2 = resolveEndpointsConfig(_config_1);
-        const _config_3 = resolveRetryConfig(_config_2);
-        const _config_4 = resolveHostHeaderConfig(_config_3);
-        const _config_5 = resolveAwsAuthConfig(_config_4);
-        const _config_6 = resolveUserAgentConfig(_config_5);
-        super(_config_6);
-        this.config = _config_6;
-        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(getAwsAuthPlugin(this.config));
-        this.middlewareStack.use(getUserAgentPlugin(this.config));
+var LakeFormationClient = (function (_super) {
+    __extends(LakeFormationClient, _super);
+    function LakeFormationClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _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(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
     }
-    destroy() {
-        super.destroy();
-    }
-}
+    LakeFormationClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return LakeFormationClient;
+}(__Client));
+export { LakeFormationClient };

package/dist-es/commands/AddLFTagsToResourceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AddLFTagsToResourceRequestFilterSensitiveLog, AddLFTagsToResourceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1AddLFTagsToResourceCommand, serializeAws_restJson1AddLFTagsToResourceCommand, } from "../protocols/Aws_restJson1";
-export class AddLFTagsToResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AddLFTagsToResourceCommand = (function (_super) {
+    __extends(AddLFTagsToResourceCommand, _super);
+    function AddLFTagsToResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AddLFTagsToResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "AddLFTagsToResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "AddLFTagsToResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AddLFTagsToResourceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AddLFTagsToResourceResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AddLFTagsToResourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1AddLFTagsToResourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AddLFTagsToResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1AddLFTagsToResourceCommand(output, context);
-    }
-}
+    };
+    return AddLFTagsToResourceCommand;
+}($Command));
+export { AddLFTagsToResourceCommand };

package/dist-es/commands/AssumeDecoratedRoleWithSAMLCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AssumeDecoratedRoleWithSAMLRequestFilterSensitiveLog, AssumeDecoratedRoleWithSAMLResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1AssumeDecoratedRoleWithSAMLCommand, serializeAws_restJson1AssumeDecoratedRoleWithSAMLCommand, } from "../protocols/Aws_restJson1";
-export class AssumeDecoratedRoleWithSAMLCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var AssumeDecoratedRoleWithSAMLCommand = (function (_super) {
+    __extends(AssumeDecoratedRoleWithSAMLCommand, _super);
+    function AssumeDecoratedRoleWithSAMLCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    AssumeDecoratedRoleWithSAMLCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "AssumeDecoratedRoleWithSAMLCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "AssumeDecoratedRoleWithSAMLCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: AssumeDecoratedRoleWithSAMLRequestFilterSensitiveLog,
             outputFilterSensitiveLog: AssumeDecoratedRoleWithSAMLResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AssumeDecoratedRoleWithSAMLCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1AssumeDecoratedRoleWithSAMLCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    AssumeDecoratedRoleWithSAMLCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1AssumeDecoratedRoleWithSAMLCommand(output, context);
-    }
-}
+    };
+    return AssumeDecoratedRoleWithSAMLCommand;
+}($Command));
+export { AssumeDecoratedRoleWithSAMLCommand };

package/dist-es/commands/BatchGrantPermissionsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { BatchGrantPermissionsRequestFilterSensitiveLog, BatchGrantPermissionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1BatchGrantPermissionsCommand, serializeAws_restJson1BatchGrantPermissionsCommand, } from "../protocols/Aws_restJson1";
-export class BatchGrantPermissionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var BatchGrantPermissionsCommand = (function (_super) {
+    __extends(BatchGrantPermissionsCommand, _super);
+    function BatchGrantPermissionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    BatchGrantPermissionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "BatchGrantPermissionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "BatchGrantPermissionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: BatchGrantPermissionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: BatchGrantPermissionsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchGrantPermissionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1BatchGrantPermissionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    BatchGrantPermissionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1BatchGrantPermissionsCommand(output, context);
-    }
-}
+    };
+    return BatchGrantPermissionsCommand;
+}($Command));
+export { BatchGrantPermissionsCommand };

package/dist-es/commands/BatchRevokePermissionsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { BatchRevokePermissionsRequestFilterSensitiveLog, BatchRevokePermissionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1BatchRevokePermissionsCommand, serializeAws_restJson1BatchRevokePermissionsCommand, } from "../protocols/Aws_restJson1";
-export class BatchRevokePermissionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var BatchRevokePermissionsCommand = (function (_super) {
+    __extends(BatchRevokePermissionsCommand, _super);
+    function BatchRevokePermissionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    BatchRevokePermissionsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "BatchRevokePermissionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "BatchRevokePermissionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: BatchRevokePermissionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: BatchRevokePermissionsResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    BatchRevokePermissionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1BatchRevokePermissionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    BatchRevokePermissionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1BatchRevokePermissionsCommand(output, context);
-    }
-}
+    };
+    return BatchRevokePermissionsCommand;
+}($Command));
+export { BatchRevokePermissionsCommand };

package/dist-es/commands/CancelTransactionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CancelTransactionRequestFilterSensitiveLog, CancelTransactionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CancelTransactionCommand, serializeAws_restJson1CancelTransactionCommand, } from "../protocols/Aws_restJson1";
-export class CancelTransactionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CancelTransactionCommand = (function (_super) {
+    __extends(CancelTransactionCommand, _super);
+    function CancelTransactionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CancelTransactionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "CancelTransactionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "CancelTransactionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CancelTransactionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CancelTransactionResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CancelTransactionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CancelTransactionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CancelTransactionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CancelTransactionCommand(output, context);
-    }
-}
+    };
+    return CancelTransactionCommand;
+}($Command));
+export { CancelTransactionCommand };

package/dist-es/commands/CommitTransactionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CommitTransactionRequestFilterSensitiveLog, CommitTransactionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CommitTransactionCommand, serializeAws_restJson1CommitTransactionCommand, } from "../protocols/Aws_restJson1";
-export class CommitTransactionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CommitTransactionCommand = (function (_super) {
+    __extends(CommitTransactionCommand, _super);
+    function CommitTransactionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CommitTransactionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "CommitTransactionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "CommitTransactionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CommitTransactionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CommitTransactionResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CommitTransactionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CommitTransactionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CommitTransactionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CommitTransactionCommand(output, context);
-    }
-}
+    };
+    return CommitTransactionCommand;
+}($Command));
+export { CommitTransactionCommand };

package/dist-es/commands/CreateDataCellsFilterCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateDataCellsFilterRequestFilterSensitiveLog, CreateDataCellsFilterResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateDataCellsFilterCommand, serializeAws_restJson1CreateDataCellsFilterCommand, } from "../protocols/Aws_restJson1";
-export class CreateDataCellsFilterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateDataCellsFilterCommand = (function (_super) {
+    __extends(CreateDataCellsFilterCommand, _super);
+    function CreateDataCellsFilterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateDataCellsFilterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "CreateDataCellsFilterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "CreateDataCellsFilterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateDataCellsFilterRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateDataCellsFilterResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDataCellsFilterCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateDataCellsFilterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateDataCellsFilterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateDataCellsFilterCommand(output, context);
-    }
-}
+    };
+    return CreateDataCellsFilterCommand;
+}($Command));
+export { CreateDataCellsFilterCommand };

package/dist-es/commands/CreateLFTagCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateLFTagRequestFilterSensitiveLog, CreateLFTagResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CreateLFTagCommand, serializeAws_restJson1CreateLFTagCommand, } from "../protocols/Aws_restJson1";
-export class CreateLFTagCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var CreateLFTagCommand = (function (_super) {
+    __extends(CreateLFTagCommand, _super);
+    function CreateLFTagCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    CreateLFTagCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "CreateLFTagCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "CreateLFTagCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: CreateLFTagRequestFilterSensitiveLog,
             outputFilterSensitiveLog: CreateLFTagResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateLFTagCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1CreateLFTagCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    CreateLFTagCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1CreateLFTagCommand(output, context);
-    }
-}
+    };
+    return CreateLFTagCommand;
+}($Command));
+export { CreateLFTagCommand };

package/dist-es/commands/DeleteDataCellsFilterCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteDataCellsFilterRequestFilterSensitiveLog, DeleteDataCellsFilterResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1DeleteDataCellsFilterCommand, serializeAws_restJson1DeleteDataCellsFilterCommand, } from "../protocols/Aws_restJson1";
-export class DeleteDataCellsFilterCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteDataCellsFilterCommand = (function (_super) {
+    __extends(DeleteDataCellsFilterCommand, _super);
+    function DeleteDataCellsFilterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteDataCellsFilterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "LakeFormationClient";
-        const commandName = "DeleteDataCellsFilterCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "DeleteDataCellsFilterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteDataCellsFilterRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteDataCellsFilterResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDataCellsFilterCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1DeleteDataCellsFilterCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteDataCellsFilterCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1DeleteDataCellsFilterCommand(output, context);
-    }
-}
+    };
+    return DeleteDataCellsFilterCommand;
+}($Command));
+export { DeleteDataCellsFilterCommand };