@aws-sdk/client-lakeformation 3.183.0 → 3.186.0

package/dist-es/commands/ListPermissionsCommand.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 { ListPermissionsRequestFilterSensitiveLog, ListPermissionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListPermissionsCommand, serializeAws_restJson1ListPermissionsCommand, } from "../protocols/Aws_restJson1";
-export class ListPermissionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListPermissionsCommand = (function (_super) {
+    __extends(ListPermissionsCommand, _super);
+    function ListPermissionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListPermissionsCommand.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 = "ListPermissionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "ListPermissionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListPermissionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListPermissionsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListPermissionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListPermissionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListPermissionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListPermissionsCommand(output, context);
-    }
-}
+    };
+    return ListPermissionsCommand;
+}($Command));
+export { ListPermissionsCommand };

package/dist-es/commands/ListResourcesCommand.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 { ListResourcesRequestFilterSensitiveLog, ListResourcesResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListResourcesCommand, serializeAws_restJson1ListResourcesCommand, } from "../protocols/Aws_restJson1";
-export class ListResourcesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListResourcesCommand = (function (_super) {
+    __extends(ListResourcesCommand, _super);
+    function ListResourcesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListResourcesCommand.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 = "ListResourcesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "ListResourcesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListResourcesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListResourcesResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListResourcesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListResourcesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListResourcesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListResourcesCommand(output, context);
-    }
-}
+    };
+    return ListResourcesCommand;
+}($Command));
+export { ListResourcesCommand };

package/dist-es/commands/ListTableStorageOptimizersCommand.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 { ListTableStorageOptimizersRequestFilterSensitiveLog, ListTableStorageOptimizersResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListTableStorageOptimizersCommand, serializeAws_restJson1ListTableStorageOptimizersCommand, } from "../protocols/Aws_restJson1";
-export class ListTableStorageOptimizersCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListTableStorageOptimizersCommand = (function (_super) {
+    __extends(ListTableStorageOptimizersCommand, _super);
+    function ListTableStorageOptimizersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListTableStorageOptimizersCommand.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 = "ListTableStorageOptimizersCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "ListTableStorageOptimizersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListTableStorageOptimizersRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListTableStorageOptimizersResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListTableStorageOptimizersCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListTableStorageOptimizersCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListTableStorageOptimizersCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListTableStorageOptimizersCommand(output, context);
-    }
-}
+    };
+    return ListTableStorageOptimizersCommand;
+}($Command));
+export { ListTableStorageOptimizersCommand };

package/dist-es/commands/ListTransactionsCommand.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 { ListTransactionsRequestFilterSensitiveLog, ListTransactionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListTransactionsCommand, serializeAws_restJson1ListTransactionsCommand, } from "../protocols/Aws_restJson1";
-export class ListTransactionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListTransactionsCommand = (function (_super) {
+    __extends(ListTransactionsCommand, _super);
+    function ListTransactionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListTransactionsCommand.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 = "ListTransactionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "ListTransactionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListTransactionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ListTransactionsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    ListTransactionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListTransactionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListTransactionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListTransactionsCommand(output, context);
-    }
-}
+    };
+    return ListTransactionsCommand;
+}($Command));
+export { ListTransactionsCommand };

package/dist-es/commands/PutDataLakeSettingsCommand.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 { PutDataLakeSettingsRequestFilterSensitiveLog, PutDataLakeSettingsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1PutDataLakeSettingsCommand, serializeAws_restJson1PutDataLakeSettingsCommand, } from "../protocols/Aws_restJson1";
-export class PutDataLakeSettingsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutDataLakeSettingsCommand = (function (_super) {
+    __extends(PutDataLakeSettingsCommand, _super);
+    function PutDataLakeSettingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutDataLakeSettingsCommand.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 = "PutDataLakeSettingsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "PutDataLakeSettingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutDataLakeSettingsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: PutDataLakeSettingsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    PutDataLakeSettingsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1PutDataLakeSettingsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutDataLakeSettingsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1PutDataLakeSettingsCommand(output, context);
-    }
-}
+    };
+    return PutDataLakeSettingsCommand;
+}($Command));
+export { PutDataLakeSettingsCommand };

package/dist-es/commands/RegisterResourceCommand.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 { RegisterResourceRequestFilterSensitiveLog, RegisterResourceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1RegisterResourceCommand, serializeAws_restJson1RegisterResourceCommand, } from "../protocols/Aws_restJson1";
-export class RegisterResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RegisterResourceCommand = (function (_super) {
+    __extends(RegisterResourceCommand, _super);
+    function RegisterResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RegisterResourceCommand.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 = "RegisterResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "RegisterResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RegisterResourceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RegisterResourceResponseFilterSensitiveLog,
         };
-        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);
+    };
+    RegisterResourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1RegisterResourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RegisterResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1RegisterResourceCommand(output, context);
-    }
-}
+    };
+    return RegisterResourceCommand;
+}($Command));
+export { RegisterResourceCommand };

package/dist-es/commands/RemoveLFTagsFromResourceCommand.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 { RemoveLFTagsFromResourceRequestFilterSensitiveLog, RemoveLFTagsFromResourceResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1RemoveLFTagsFromResourceCommand, serializeAws_restJson1RemoveLFTagsFromResourceCommand, } from "../protocols/Aws_restJson1";
-export class RemoveLFTagsFromResourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RemoveLFTagsFromResourceCommand = (function (_super) {
+    __extends(RemoveLFTagsFromResourceCommand, _super);
+    function RemoveLFTagsFromResourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RemoveLFTagsFromResourceCommand.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 = "RemoveLFTagsFromResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "RemoveLFTagsFromResourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RemoveLFTagsFromResourceRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RemoveLFTagsFromResourceResponseFilterSensitiveLog,
         };
-        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);
+    };
+    RemoveLFTagsFromResourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1RemoveLFTagsFromResourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RemoveLFTagsFromResourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1RemoveLFTagsFromResourceCommand(output, context);
-    }
-}
+    };
+    return RemoveLFTagsFromResourceCommand;
+}($Command));
+export { RemoveLFTagsFromResourceCommand };

package/dist-es/commands/RevokePermissionsCommand.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 { RevokePermissionsRequestFilterSensitiveLog, RevokePermissionsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1RevokePermissionsCommand, serializeAws_restJson1RevokePermissionsCommand, } from "../protocols/Aws_restJson1";
-export class RevokePermissionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RevokePermissionsCommand = (function (_super) {
+    __extends(RevokePermissionsCommand, _super);
+    function RevokePermissionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RevokePermissionsCommand.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 = "RevokePermissionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "RevokePermissionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RevokePermissionsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RevokePermissionsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    RevokePermissionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1RevokePermissionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RevokePermissionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1RevokePermissionsCommand(output, context);
-    }
-}
+    };
+    return RevokePermissionsCommand;
+}($Command));
+export { RevokePermissionsCommand };

package/dist-es/commands/SearchDatabasesByLFTagsCommand.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 { SearchDatabasesByLFTagsRequestFilterSensitiveLog, SearchDatabasesByLFTagsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1SearchDatabasesByLFTagsCommand, serializeAws_restJson1SearchDatabasesByLFTagsCommand, } from "../protocols/Aws_restJson1";
-export class SearchDatabasesByLFTagsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SearchDatabasesByLFTagsCommand = (function (_super) {
+    __extends(SearchDatabasesByLFTagsCommand, _super);
+    function SearchDatabasesByLFTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SearchDatabasesByLFTagsCommand.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 = "SearchDatabasesByLFTagsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "SearchDatabasesByLFTagsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SearchDatabasesByLFTagsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SearchDatabasesByLFTagsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    SearchDatabasesByLFTagsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SearchDatabasesByLFTagsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SearchDatabasesByLFTagsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SearchDatabasesByLFTagsCommand(output, context);
-    }
-}
+    };
+    return SearchDatabasesByLFTagsCommand;
+}($Command));
+export { SearchDatabasesByLFTagsCommand };

package/dist-es/commands/SearchTablesByLFTagsCommand.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 { SearchTablesByLFTagsRequestFilterSensitiveLog, SearchTablesByLFTagsResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1SearchTablesByLFTagsCommand, serializeAws_restJson1SearchTablesByLFTagsCommand, } from "../protocols/Aws_restJson1";
-export class SearchTablesByLFTagsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var SearchTablesByLFTagsCommand = (function (_super) {
+    __extends(SearchTablesByLFTagsCommand, _super);
+    function SearchTablesByLFTagsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    SearchTablesByLFTagsCommand.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 = "SearchTablesByLFTagsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "LakeFormationClient";
+        var commandName = "SearchTablesByLFTagsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: SearchTablesByLFTagsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: SearchTablesByLFTagsResponseFilterSensitiveLog,
         };
-        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);
+    };
+    SearchTablesByLFTagsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1SearchTablesByLFTagsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    SearchTablesByLFTagsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1SearchTablesByLFTagsCommand(output, context);
-    }
-}
+    };
+    return SearchTablesByLFTagsCommand;
+}($Command));
+export { SearchTablesByLFTagsCommand };