@aws-sdk/client-lakeformation 3.41.0 → 3.45.0

package/dist-es/LakeFormation.js

@@ -2,26 +2,45 @@ import { __extends } from "tslib";
 import { AddLFTagsToResourceCommand, } from "./commands/AddLFTagsToResourceCommand";
 import { BatchGrantPermissionsCommand, } from "./commands/BatchGrantPermissionsCommand";
 import { BatchRevokePermissionsCommand, } from "./commands/BatchRevokePermissionsCommand";
+import { CancelTransactionCommand, } from "./commands/CancelTransactionCommand";
+import { CommitTransactionCommand, } from "./commands/CommitTransactionCommand";
+import { CreateDataCellsFilterCommand, } from "./commands/CreateDataCellsFilterCommand";
 import { CreateLFTagCommand } from "./commands/CreateLFTagCommand";
+import { DeleteDataCellsFilterCommand, } from "./commands/DeleteDataCellsFilterCommand";
 import { DeleteLFTagCommand } from "./commands/DeleteLFTagCommand";
+import { DeleteObjectsOnCancelCommand, } from "./commands/DeleteObjectsOnCancelCommand";
 import { DeregisterResourceCommand, } from "./commands/DeregisterResourceCommand";
 import { DescribeResourceCommand, } from "./commands/DescribeResourceCommand";
+import { DescribeTransactionCommand, } from "./commands/DescribeTransactionCommand";
+import { ExtendTransactionCommand, } from "./commands/ExtendTransactionCommand";
 import { GetDataLakeSettingsCommand, } from "./commands/GetDataLakeSettingsCommand";
 import { GetEffectivePermissionsForPathCommand, } from "./commands/GetEffectivePermissionsForPathCommand";
 import { GetLFTagCommand } from "./commands/GetLFTagCommand";
+import { GetQueryStateCommand, } from "./commands/GetQueryStateCommand";
+import { GetQueryStatisticsCommand, } from "./commands/GetQueryStatisticsCommand";
 import { GetResourceLFTagsCommand, } from "./commands/GetResourceLFTagsCommand";
+import { GetTableObjectsCommand, } from "./commands/GetTableObjectsCommand";
+import { GetWorkUnitResultsCommand, } from "./commands/GetWorkUnitResultsCommand";
+import { GetWorkUnitsCommand, } from "./commands/GetWorkUnitsCommand";
 import { GrantPermissionsCommand, } from "./commands/GrantPermissionsCommand";
+import { ListDataCellsFilterCommand, } from "./commands/ListDataCellsFilterCommand";
 import { ListLFTagsCommand } from "./commands/ListLFTagsCommand";
 import { ListPermissionsCommand, } from "./commands/ListPermissionsCommand";
 import { ListResourcesCommand, } from "./commands/ListResourcesCommand";
+import { ListTableStorageOptimizersCommand, } from "./commands/ListTableStorageOptimizersCommand";
+import { ListTransactionsCommand, } from "./commands/ListTransactionsCommand";
 import { PutDataLakeSettingsCommand, } from "./commands/PutDataLakeSettingsCommand";
 import { RegisterResourceCommand, } from "./commands/RegisterResourceCommand";
 import { RemoveLFTagsFromResourceCommand, } from "./commands/RemoveLFTagsFromResourceCommand";
 import { RevokePermissionsCommand, } from "./commands/RevokePermissionsCommand";
 import { SearchDatabasesByLFTagsCommand, } from "./commands/SearchDatabasesByLFTagsCommand";
 import { SearchTablesByLFTagsCommand, } from "./commands/SearchTablesByLFTagsCommand";
+import { StartQueryPlanningCommand, } from "./commands/StartQueryPlanningCommand";
+import { StartTransactionCommand, } from "./commands/StartTransactionCommand";
 import { UpdateLFTagCommand } from "./commands/UpdateLFTagCommand";
 import { UpdateResourceCommand, } from "./commands/UpdateResourceCommand";
+import { UpdateTableObjectsCommand, } from "./commands/UpdateTableObjectsCommand";
+import { UpdateTableStorageOptimizerCommand, } from "./commands/UpdateTableStorageOptimizerCommand";
 import { LakeFormationClient } from "./LakeFormationClient";
 var LakeFormation = (function (_super) {
     __extends(LakeFormation, _super);
@@ -70,6 +89,48 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.cancelTransaction = function (args, optionsOrCb, cb) {
+        var command = new CancelTransactionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.commitTransaction = function (args, optionsOrCb, cb) {
+        var command = new CommitTransactionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.createDataCellsFilter = function (args, optionsOrCb, cb) {
+        var command = new CreateDataCellsFilterCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.createLFTag = function (args, optionsOrCb, cb) {
         var command = new CreateLFTagCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -84,6 +145,20 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.deleteDataCellsFilter = function (args, optionsOrCb, cb) {
+        var command = new DeleteDataCellsFilterCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.deleteLFTag = function (args, optionsOrCb, cb) {
         var command = new DeleteLFTagCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -98,6 +173,20 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.deleteObjectsOnCancel = function (args, optionsOrCb, cb) {
+        var command = new DeleteObjectsOnCancelCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.deregisterResource = function (args, optionsOrCb, cb) {
         var command = new DeregisterResourceCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -126,6 +215,34 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.describeTransaction = function (args, optionsOrCb, cb) {
+        var command = new DescribeTransactionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.extendTransaction = function (args, optionsOrCb, cb) {
+        var command = new ExtendTransactionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.getDataLakeSettings = function (args, optionsOrCb, cb) {
         var command = new GetDataLakeSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -168,6 +285,34 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.getQueryState = function (args, optionsOrCb, cb) {
+        var command = new GetQueryStateCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.getQueryStatistics = function (args, optionsOrCb, cb) {
+        var command = new GetQueryStatisticsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.getResourceLFTags = function (args, optionsOrCb, cb) {
         var command = new GetResourceLFTagsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -182,6 +327,48 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.getTableObjects = function (args, optionsOrCb, cb) {
+        var command = new GetTableObjectsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.getWorkUnitResults = function (args, optionsOrCb, cb) {
+        var command = new GetWorkUnitResultsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.getWorkUnits = function (args, optionsOrCb, cb) {
+        var command = new GetWorkUnitsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.grantPermissions = function (args, optionsOrCb, cb) {
         var command = new GrantPermissionsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -196,6 +383,20 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.listDataCellsFilter = function (args, optionsOrCb, cb) {
+        var command = new ListDataCellsFilterCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.listLFTags = function (args, optionsOrCb, cb) {
         var command = new ListLFTagsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -238,6 +439,34 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.listTableStorageOptimizers = function (args, optionsOrCb, cb) {
+        var command = new ListTableStorageOptimizersCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.listTransactions = function (args, optionsOrCb, cb) {
+        var command = new ListTransactionsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.putDataLakeSettings = function (args, optionsOrCb, cb) {
         var command = new PutDataLakeSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -322,6 +551,34 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.startQueryPlanning = function (args, optionsOrCb, cb) {
+        var command = new StartQueryPlanningCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.startTransaction = function (args, optionsOrCb, cb) {
+        var command = new StartTransactionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     LakeFormation.prototype.updateLFTag = function (args, optionsOrCb, cb) {
         var command = new UpdateLFTagCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -350,6 +607,34 @@ var LakeFormation = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    LakeFormation.prototype.updateTableObjects = function (args, optionsOrCb, cb) {
+        var command = new UpdateTableObjectsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    LakeFormation.prototype.updateTableStorageOptimizer = function (args, optionsOrCb, cb) {
+        var command = new UpdateTableStorageOptimizerCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get " + typeof optionsOrCb);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     return LakeFormation;
 }(LakeFormationClient));
 export { LakeFormation };

package/dist-es/commands/AddLFTagsToResourceCommand.js

@@ -2,7 +2,7 @@ import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { AddLFTagsToResourceRequest, AddLFTagsToResourceResponse } from "../models/models_0";
-import { deserializeAws_json1_1AddLFTagsToResourceCommand, serializeAws_json1_1AddLFTagsToResourceCommand, } from "../protocols/Aws_json1_1";
+import { deserializeAws_restJson1AddLFTagsToResourceCommand, serializeAws_restJson1AddLFTagsToResourceCommand, } from "../protocols/Aws_restJson1";
 var AddLFTagsToResourceCommand = (function (_super) {
     __extends(AddLFTagsToResourceCommand, _super);
     function AddLFTagsToResourceCommand(input) {
@@ -29,10 +29,10 @@ var AddLFTagsToResourceCommand = (function (_super) {
         }, handlerExecutionContext);
     };
     AddLFTagsToResourceCommand.prototype.serialize = function (input, context) {
-        return serializeAws_json1_1AddLFTagsToResourceCommand(input, context);
+        return serializeAws_restJson1AddLFTagsToResourceCommand(input, context);
     };
     AddLFTagsToResourceCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_json1_1AddLFTagsToResourceCommand(output, context);
+        return deserializeAws_restJson1AddLFTagsToResourceCommand(output, context);
     };
     return AddLFTagsToResourceCommand;
 }($Command));

package/dist-es/commands/BatchGrantPermissionsCommand.js

@@ -2,7 +2,7 @@ import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { BatchGrantPermissionsRequest, BatchGrantPermissionsResponse } from "../models/models_0";
-import { deserializeAws_json1_1BatchGrantPermissionsCommand, serializeAws_json1_1BatchGrantPermissionsCommand, } from "../protocols/Aws_json1_1";
+import { deserializeAws_restJson1BatchGrantPermissionsCommand, serializeAws_restJson1BatchGrantPermissionsCommand, } from "../protocols/Aws_restJson1";
 var BatchGrantPermissionsCommand = (function (_super) {
     __extends(BatchGrantPermissionsCommand, _super);
     function BatchGrantPermissionsCommand(input) {
@@ -29,10 +29,10 @@ var BatchGrantPermissionsCommand = (function (_super) {
         }, handlerExecutionContext);
     };
     BatchGrantPermissionsCommand.prototype.serialize = function (input, context) {
-        return serializeAws_json1_1BatchGrantPermissionsCommand(input, context);
+        return serializeAws_restJson1BatchGrantPermissionsCommand(input, context);
     };
     BatchGrantPermissionsCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_json1_1BatchGrantPermissionsCommand(output, context);
+        return deserializeAws_restJson1BatchGrantPermissionsCommand(output, context);
     };
     return BatchGrantPermissionsCommand;
 }($Command));

package/dist-es/commands/BatchRevokePermissionsCommand.js

@@ -2,7 +2,7 @@ import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { BatchRevokePermissionsRequest, BatchRevokePermissionsResponse } from "../models/models_0";
-import { deserializeAws_json1_1BatchRevokePermissionsCommand, serializeAws_json1_1BatchRevokePermissionsCommand, } from "../protocols/Aws_json1_1";
+import { deserializeAws_restJson1BatchRevokePermissionsCommand, serializeAws_restJson1BatchRevokePermissionsCommand, } from "../protocols/Aws_restJson1";
 var BatchRevokePermissionsCommand = (function (_super) {
     __extends(BatchRevokePermissionsCommand, _super);
     function BatchRevokePermissionsCommand(input) {
@@ -29,10 +29,10 @@ var BatchRevokePermissionsCommand = (function (_super) {
         }, handlerExecutionContext);
     };
     BatchRevokePermissionsCommand.prototype.serialize = function (input, context) {
-        return serializeAws_json1_1BatchRevokePermissionsCommand(input, context);
+        return serializeAws_restJson1BatchRevokePermissionsCommand(input, context);
     };
     BatchRevokePermissionsCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_json1_1BatchRevokePermissionsCommand(output, context);
+        return deserializeAws_restJson1BatchRevokePermissionsCommand(output, context);
     };
     return BatchRevokePermissionsCommand;
 }($Command));

package/dist-es/commands/CancelTransactionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CancelTransactionRequest, CancelTransactionResponse } from "../models/models_0";
+import { deserializeAws_restJson1CancelTransactionCommand, serializeAws_restJson1CancelTransactionCommand, } from "../protocols/Aws_restJson1";
+var CancelTransactionCommand = (function (_super) {
+    __extends(CancelTransactionCommand, _super);
+    function CancelTransactionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CancelTransactionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: CancelTransactionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CancelTransactionResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    CancelTransactionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CancelTransactionCommand(output, context);
+    };
+    return CancelTransactionCommand;
+}($Command));
+export { CancelTransactionCommand };

package/dist-es/commands/CommitTransactionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CommitTransactionRequest, CommitTransactionResponse } from "../models/models_0";
+import { deserializeAws_restJson1CommitTransactionCommand, serializeAws_restJson1CommitTransactionCommand, } from "../protocols/Aws_restJson1";
+var CommitTransactionCommand = (function (_super) {
+    __extends(CommitTransactionCommand, _super);
+    function CommitTransactionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CommitTransactionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: CommitTransactionRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CommitTransactionResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    CommitTransactionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CommitTransactionCommand(output, context);
+    };
+    return CommitTransactionCommand;
+}($Command));
+export { CommitTransactionCommand };

package/dist-es/commands/CreateDataCellsFilterCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDataCellsFilterRequest, CreateDataCellsFilterResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateDataCellsFilterCommand, serializeAws_restJson1CreateDataCellsFilterCommand, } from "../protocols/Aws_restJson1";
+var CreateDataCellsFilterCommand = (function (_super) {
+    __extends(CreateDataCellsFilterCommand, _super);
+    function CreateDataCellsFilterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDataCellsFilterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: CreateDataCellsFilterRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDataCellsFilterResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    CreateDataCellsFilterCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateDataCellsFilterCommand(output, context);
+    };
+    return CreateDataCellsFilterCommand;
+}($Command));
+export { CreateDataCellsFilterCommand };

package/dist-es/commands/CreateLFTagCommand.js

@@ -2,7 +2,7 @@ import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { CreateLFTagRequest, CreateLFTagResponse } from "../models/models_0";
-import { deserializeAws_json1_1CreateLFTagCommand, serializeAws_json1_1CreateLFTagCommand, } from "../protocols/Aws_json1_1";
+import { deserializeAws_restJson1CreateLFTagCommand, serializeAws_restJson1CreateLFTagCommand, } from "../protocols/Aws_restJson1";
 var CreateLFTagCommand = (function (_super) {
     __extends(CreateLFTagCommand, _super);
     function CreateLFTagCommand(input) {
@@ -29,10 +29,10 @@ var CreateLFTagCommand = (function (_super) {
         }, handlerExecutionContext);
     };
     CreateLFTagCommand.prototype.serialize = function (input, context) {
-        return serializeAws_json1_1CreateLFTagCommand(input, context);
+        return serializeAws_restJson1CreateLFTagCommand(input, context);
     };
     CreateLFTagCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_json1_1CreateLFTagCommand(output, context);
+        return deserializeAws_restJson1CreateLFTagCommand(output, context);
     };
     return CreateLFTagCommand;
 }($Command));

package/dist-es/commands/DeleteDataCellsFilterCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteDataCellsFilterRequest, DeleteDataCellsFilterResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteDataCellsFilterCommand, serializeAws_restJson1DeleteDataCellsFilterCommand, } from "../protocols/Aws_restJson1";
+var DeleteDataCellsFilterCommand = (function (_super) {
+    __extends(DeleteDataCellsFilterCommand, _super);
+    function DeleteDataCellsFilterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteDataCellsFilterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        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: DeleteDataCellsFilterRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDataCellsFilterResponse.filterSensitiveLog,
+        };
+        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);
+    };
+    DeleteDataCellsFilterCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteDataCellsFilterCommand(output, context);
+    };
+    return DeleteDataCellsFilterCommand;
+}($Command));
+export { DeleteDataCellsFilterCommand };

package/dist-es/commands/DeleteLFTagCommand.js

@@ -2,7 +2,7 @@ import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteLFTagRequest, DeleteLFTagResponse } from "../models/models_0";
-import { deserializeAws_json1_1DeleteLFTagCommand, serializeAws_json1_1DeleteLFTagCommand, } from "../protocols/Aws_json1_1";
+import { deserializeAws_restJson1DeleteLFTagCommand, serializeAws_restJson1DeleteLFTagCommand, } from "../protocols/Aws_restJson1";
 var DeleteLFTagCommand = (function (_super) {
     __extends(DeleteLFTagCommand, _super);
     function DeleteLFTagCommand(input) {
@@ -29,10 +29,10 @@ var DeleteLFTagCommand = (function (_super) {
         }, handlerExecutionContext);
     };
     DeleteLFTagCommand.prototype.serialize = function (input, context) {
-        return serializeAws_json1_1DeleteLFTagCommand(input, context);
+        return serializeAws_restJson1DeleteLFTagCommand(input, context);
     };
     DeleteLFTagCommand.prototype.deserialize = function (output, context) {
-        return deserializeAws_json1_1DeleteLFTagCommand(output, context);
+        return deserializeAws_restJson1DeleteLFTagCommand(output, context);
     };
     return DeleteLFTagCommand;
 }($Command));