@aws-sdk/client-lakeformation 3.42.0 → 3.46.0

package/dist-types/commands/DeleteObjectsOnCancelCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { DeleteObjectsOnCancelRequest, DeleteObjectsOnCancelResponse } from "../models/models_0";
+export interface DeleteObjectsOnCancelCommandInput extends DeleteObjectsOnCancelRequest {
+}
+export interface DeleteObjectsOnCancelCommandOutput extends DeleteObjectsOnCancelResponse, __MetadataBearer {
+}
+/**
+ * <p>For a specific governed table, provides a list of Amazon S3 objects that will be written during the current transaction and that can be automatically deleted
+ *       if the transaction is canceled. Without this call, no Amazon S3 objects are automatically deleted when a transaction cancels.
+ *     </p>
+ *          <p>
+ *       The Glue ETL library function <code>write_dynamic_frame.from_catalog()</code> includes an option to automatically
+ *       call <code>DeleteObjectsOnCancel</code> before writes. For more information, see
+ *       <a href="https://docs.aws.amazon.com/lake-formation/latest/dg/transactions-data-operations.html#rolling-back-writes">Rolling Back Amazon S3 Writes</a>.
+ *     </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, DeleteObjectsOnCancelCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, DeleteObjectsOnCancelCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new DeleteObjectsOnCancelCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteObjectsOnCancelCommandInput} for command's `input` shape.
+ * @see {@link DeleteObjectsOnCancelCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class DeleteObjectsOnCancelCommand extends $Command<DeleteObjectsOnCancelCommandInput, DeleteObjectsOnCancelCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: DeleteObjectsOnCancelCommandInput;
+    constructor(input: DeleteObjectsOnCancelCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteObjectsOnCancelCommandInput, DeleteObjectsOnCancelCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DescribeResourceCommand.d.ts

@@ -7,7 +7,7 @@ export interface DescribeResourceCommandInput extends DescribeResourceRequest {
 export interface DescribeResourceCommandOutput extends DescribeResourceResponse, __MetadataBearer {
 }
 /**
- * <p>Retrieves the current data access role for the given resource registered in AWS Lake Formation.</p>
+ * <p>Retrieves the current data access role for the given resource registered in Lake Formation.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/DescribeTransactionCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { DescribeTransactionRequest, DescribeTransactionResponse } from "../models/models_0";
+export interface DescribeTransactionCommandInput extends DescribeTransactionRequest {
+}
+export interface DescribeTransactionCommandOutput extends DescribeTransactionResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the details of a single transaction.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, DescribeTransactionCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, DescribeTransactionCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new DescribeTransactionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribeTransactionCommandInput} for command's `input` shape.
+ * @see {@link DescribeTransactionCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class DescribeTransactionCommand extends $Command<DescribeTransactionCommandInput, DescribeTransactionCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: DescribeTransactionCommandInput;
+    constructor(input: DescribeTransactionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransactionCommandInput, DescribeTransactionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ExtendTransactionCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { ExtendTransactionRequest, ExtendTransactionResponse } from "../models/models_0";
+export interface ExtendTransactionCommandInput extends ExtendTransactionRequest {
+}
+export interface ExtendTransactionCommandOutput extends ExtendTransactionResponse, __MetadataBearer {
+}
+/**
+ * <p>Indicates to the service that the specified transaction is still active and should not be treated as idle and aborted.</p>
+ *
+ * 	        <p>Write transactions that remain idle for a long period are automatically aborted unless explicitly extended.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, ExtendTransactionCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, ExtendTransactionCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new ExtendTransactionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ExtendTransactionCommandInput} for command's `input` shape.
+ * @see {@link ExtendTransactionCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class ExtendTransactionCommand extends $Command<ExtendTransactionCommandInput, ExtendTransactionCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: ExtendTransactionCommandInput;
+    constructor(input: ExtendTransactionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExtendTransactionCommandInput, ExtendTransactionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetLFTagCommand.d.ts

@@ -7,7 +7,7 @@ export interface GetLFTagCommandInput extends GetLFTagRequest {
 export interface GetLFTagCommandOutput extends GetLFTagResponse, __MetadataBearer {
 }
 /**
- * <p>Returns a tag definition.</p>
+ * <p>Returns an LF-tag definition.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/GetQueryStateCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { GetQueryStateRequest, GetQueryStateResponse } from "../models/models_0";
+export interface GetQueryStateCommandInput extends GetQueryStateRequest {
+}
+export interface GetQueryStateCommandOutput extends GetQueryStateResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the state of a query previously submitted. Clients are expected to poll <code>GetQueryState</code> to monitor the current state of the planning before retrieving the work units. A query state is only visible to the principal that made the initial call to <code>StartQueryPlanning</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, GetQueryStateCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, GetQueryStateCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new GetQueryStateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetQueryStateCommandInput} for command's `input` shape.
+ * @see {@link GetQueryStateCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class GetQueryStateCommand extends $Command<GetQueryStateCommandInput, GetQueryStateCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: GetQueryStateCommandInput;
+    constructor(input: GetQueryStateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetQueryStateCommandInput, GetQueryStateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetQueryStatisticsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { GetQueryStatisticsRequest, GetQueryStatisticsResponse } from "../models/models_0";
+export interface GetQueryStatisticsCommandInput extends GetQueryStatisticsRequest {
+}
+export interface GetQueryStatisticsCommandOutput extends GetQueryStatisticsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves statistics on the planning and execution of a query.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, GetQueryStatisticsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, GetQueryStatisticsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new GetQueryStatisticsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetQueryStatisticsCommandInput} for command's `input` shape.
+ * @see {@link GetQueryStatisticsCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class GetQueryStatisticsCommand extends $Command<GetQueryStatisticsCommandInput, GetQueryStatisticsCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: GetQueryStatisticsCommandInput;
+    constructor(input: GetQueryStatisticsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetQueryStatisticsCommandInput, GetQueryStatisticsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetResourceLFTagsCommand.d.ts

@@ -7,7 +7,7 @@ export interface GetResourceLFTagsCommandInput extends GetResourceLFTagsRequest
 export interface GetResourceLFTagsCommandOutput extends GetResourceLFTagsResponse, __MetadataBearer {
 }
 /**
- * <p>Returns the tags applied to a resource.</p>
+ * <p>Returns the LF-tags applied to a resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/GetTableObjectsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { GetTableObjectsRequest, GetTableObjectsResponse } from "../models/models_0";
+export interface GetTableObjectsCommandInput extends GetTableObjectsRequest {
+}
+export interface GetTableObjectsCommandOutput extends GetTableObjectsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the set of Amazon S3 objects that make up the specified governed table. A transaction ID or timestamp can be specified for time-travel queries.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, GetTableObjectsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, GetTableObjectsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new GetTableObjectsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTableObjectsCommandInput} for command's `input` shape.
+ * @see {@link GetTableObjectsCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class GetTableObjectsCommand extends $Command<GetTableObjectsCommandInput, GetTableObjectsCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: GetTableObjectsCommandInput;
+    constructor(input: GetTableObjectsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTableObjectsCommandInput, GetTableObjectsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetTemporaryGluePartitionCredentialsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { GetTemporaryGluePartitionCredentialsRequest, GetTemporaryGluePartitionCredentialsResponse } from "../models/models_0";
+export interface GetTemporaryGluePartitionCredentialsCommandInput extends GetTemporaryGluePartitionCredentialsRequest {
+}
+export interface GetTemporaryGluePartitionCredentialsCommandOutput extends GetTemporaryGluePartitionCredentialsResponse, __MetadataBearer {
+}
+/**
+ * <p>This API is identical to <code>GetTemporaryTableCredentials</code> except that this is used when the target Data Catalog resource is of type Partition.  Lake Formation restricts the permission of the vended credentials with the same scope down policy which restricts access to a single Amazon S3 prefix.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, GetTemporaryGluePartitionCredentialsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, GetTemporaryGluePartitionCredentialsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new GetTemporaryGluePartitionCredentialsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTemporaryGluePartitionCredentialsCommandInput} for command's `input` shape.
+ * @see {@link GetTemporaryGluePartitionCredentialsCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class GetTemporaryGluePartitionCredentialsCommand extends $Command<GetTemporaryGluePartitionCredentialsCommandInput, GetTemporaryGluePartitionCredentialsCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: GetTemporaryGluePartitionCredentialsCommandInput;
+    constructor(input: GetTemporaryGluePartitionCredentialsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTemporaryGluePartitionCredentialsCommandInput, GetTemporaryGluePartitionCredentialsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetTemporaryGlueTableCredentialsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { GetTemporaryGlueTableCredentialsRequest, GetTemporaryGlueTableCredentialsResponse } from "../models/models_0";
+export interface GetTemporaryGlueTableCredentialsCommandInput extends GetTemporaryGlueTableCredentialsRequest {
+}
+export interface GetTemporaryGlueTableCredentialsCommandOutput extends GetTemporaryGlueTableCredentialsResponse, __MetadataBearer {
+}
+/**
+ * <p>Allows a caller in a secure environment to assume a role with permission to access Amazon S3. In order to vend such credentials, Lake Formation assumes the role associated with a registered location, for example an Amazon S3 bucket, with a scope down policy which restricts the access to a single prefix.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, GetTemporaryGlueTableCredentialsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, GetTemporaryGlueTableCredentialsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new GetTemporaryGlueTableCredentialsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTemporaryGlueTableCredentialsCommandInput} for command's `input` shape.
+ * @see {@link GetTemporaryGlueTableCredentialsCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class GetTemporaryGlueTableCredentialsCommand extends $Command<GetTemporaryGlueTableCredentialsCommandInput, GetTemporaryGlueTableCredentialsCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: GetTemporaryGlueTableCredentialsCommandInput;
+    constructor(input: GetTemporaryGlueTableCredentialsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTemporaryGlueTableCredentialsCommandInput, GetTemporaryGlueTableCredentialsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetWorkUnitResultsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { GetWorkUnitResultsRequest, GetWorkUnitResultsResponse } from "../models/models_0";
+export interface GetWorkUnitResultsCommandInput extends GetWorkUnitResultsRequest {
+}
+export interface GetWorkUnitResultsCommandOutput extends GetWorkUnitResultsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the work units resulting from the query. Work units can be executed in any order and in parallel. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, GetWorkUnitResultsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, GetWorkUnitResultsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new GetWorkUnitResultsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetWorkUnitResultsCommandInput} for command's `input` shape.
+ * @see {@link GetWorkUnitResultsCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class GetWorkUnitResultsCommand extends $Command<GetWorkUnitResultsCommandInput, GetWorkUnitResultsCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: GetWorkUnitResultsCommandInput;
+    constructor(input: GetWorkUnitResultsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetWorkUnitResultsCommandInput, GetWorkUnitResultsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetWorkUnitsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { GetWorkUnitsRequest, GetWorkUnitsResponse } from "../models/models_0";
+export interface GetWorkUnitsCommandInput extends GetWorkUnitsRequest {
+}
+export interface GetWorkUnitsCommandOutput extends GetWorkUnitsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the work units generated by the <code>StartQueryPlanning</code> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, GetWorkUnitsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, GetWorkUnitsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new GetWorkUnitsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetWorkUnitsCommandInput} for command's `input` shape.
+ * @see {@link GetWorkUnitsCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class GetWorkUnitsCommand extends $Command<GetWorkUnitsCommandInput, GetWorkUnitsCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: GetWorkUnitsCommandInput;
+    constructor(input: GetWorkUnitsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetWorkUnitsCommandInput, GetWorkUnitsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDataCellsFilterCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { ListDataCellsFilterRequest, ListDataCellsFilterResponse } from "../models/models_0";
+export interface ListDataCellsFilterCommandInput extends ListDataCellsFilterRequest {
+}
+export interface ListDataCellsFilterCommandOutput extends ListDataCellsFilterResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all the data cell filters on a table.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, ListDataCellsFilterCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, ListDataCellsFilterCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new ListDataCellsFilterCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDataCellsFilterCommandInput} for command's `input` shape.
+ * @see {@link ListDataCellsFilterCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class ListDataCellsFilterCommand extends $Command<ListDataCellsFilterCommandInput, ListDataCellsFilterCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: ListDataCellsFilterCommandInput;
+    constructor(input: ListDataCellsFilterCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDataCellsFilterCommandInput, ListDataCellsFilterCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListLFTagsCommand.d.ts

@@ -7,7 +7,7 @@ export interface ListLFTagsCommandInput extends ListLFTagsRequest {
 export interface ListLFTagsCommandOutput extends ListLFTagsResponse, __MetadataBearer {
 }
 /**
- * <p>Lists tags that the requester has permission to view. </p>
+ * <p>Lists LF-tags that the requester has permission to view. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/ListTableStorageOptimizersCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { ListTableStorageOptimizersRequest, ListTableStorageOptimizersResponse } from "../models/models_0";
+export interface ListTableStorageOptimizersCommandInput extends ListTableStorageOptimizersRequest {
+}
+export interface ListTableStorageOptimizersCommandOutput extends ListTableStorageOptimizersResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the configuration of all storage optimizers associated with a specified table.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, ListTableStorageOptimizersCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, ListTableStorageOptimizersCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new ListTableStorageOptimizersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTableStorageOptimizersCommandInput} for command's `input` shape.
+ * @see {@link ListTableStorageOptimizersCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class ListTableStorageOptimizersCommand extends $Command<ListTableStorageOptimizersCommandInput, ListTableStorageOptimizersCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: ListTableStorageOptimizersCommandInput;
+    constructor(input: ListTableStorageOptimizersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTableStorageOptimizersCommandInput, ListTableStorageOptimizersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTransactionsCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { ListTransactionsRequest, ListTransactionsResponse } from "../models/models_0";
+export interface ListTransactionsCommandInput extends ListTransactionsRequest {
+}
+export interface ListTransactionsCommandOutput extends ListTransactionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns metadata about transactions and their status. To prevent the response from growing indefinitely, only uncommitted transactions and those available for time-travel queries are returned.</p>
+ * 	        <p>This operation can help you identify uncommitted transactions or to get information about transactions.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, ListTransactionsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, ListTransactionsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new ListTransactionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTransactionsCommandInput} for command's `input` shape.
+ * @see {@link ListTransactionsCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class ListTransactionsCommand extends $Command<ListTransactionsCommandInput, ListTransactionsCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: ListTransactionsCommandInput;
+    constructor(input: ListTransactionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTransactionsCommandInput, ListTransactionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RegisterResourceCommand.d.ts

@@ -9,9 +9,9 @@ export interface RegisterResourceCommandOutput extends RegisterResourceResponse,
 /**
  * <p>Registers the resource as managed by the Data Catalog.</p>
  *
- * 	        <p>To add or update data, Lake Formation needs read/write access to the chosen Amazon S3 path. Choose a role that you know has permission to do this, or choose the AWSServiceRoleForLakeFormationDataAccess service-linked role. When you register the first Amazon S3 path, the service-linked role and a new inline policy are created on your behalf. Lake Formation adds the first path to the inline policy and attaches it to the service-linked role. When you register subsequent paths, Lake Formation adds the path to the existing policy.</p>
+ *          <p>To add or update data, Lake Formation needs read/write access to the chosen Amazon S3 path. Choose a role that you know has permission to do this, or choose the AWSServiceRoleForLakeFormationDataAccess service-linked role. When you register the first Amazon S3 path, the service-linked role and a new inline policy are created on your behalf. Lake Formation adds the first path to the inline policy and attaches it to the service-linked role. When you register subsequent paths, Lake Formation adds the path to the existing policy.</p>
  *
- *          <p>The following request registers a new location and gives AWS Lake Formation permission to use the service-linked role to access that location.</p>
+ *          <p>The following request registers a new location and gives Lake Formation permission to use the service-linked role to access that location.</p>
  *
  *          <p>
  *             <code>ResourceArn = arn:aws:s3:::my-bucket

package/dist-types/commands/RemoveLFTagsFromResourceCommand.d.ts

@@ -7,7 +7,7 @@ export interface RemoveLFTagsFromResourceCommandInput extends RemoveLFTagsFromRe
 export interface RemoveLFTagsFromResourceCommandOutput extends RemoveLFTagsFromResourceResponse, __MetadataBearer {
 }
 /**
- * <p>Removes a tag from the resource. Only database, table, or tableWithColumns resource are allowed. To tag columns, use the column inclusion list in <code>tableWithColumns</code> to specify column input.</p>
+ * <p>Removes an LF-tag from the resource. Only database, table, or tableWithColumns resource are allowed. To tag columns, use the column inclusion list in <code>tableWithColumns</code> to specify column input.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/SearchTablesByLFTagsCommand.d.ts

@@ -7,7 +7,7 @@ export interface SearchTablesByLFTagsCommandInput extends SearchTablesByLFTagsRe
 export interface SearchTablesByLFTagsCommandOutput extends SearchTablesByLFTagsResponse, __MetadataBearer {
 }
 /**
- * <p>This operation allows a search on <code>TABLE</code> resources by <code>LFTag</code>s. This will be used by admins who want to grant user permissions on certain LFTags. Before making a grant, the admin can use <code>SearchTablesByLFTags</code> to find all resources where the given <code>LFTag</code>s are valid to verify whether the returned resources can be shared.</p>
+ * <p>This operation allows a search on <code>TABLE</code> resources by <code>LFTag</code>s. This will be used by admins who want to grant user permissions on certain LF-tags. Before making a grant, the admin can use <code>SearchTablesByLFTags</code> to find all resources where the given <code>LFTag</code>s are valid to verify whether the returned resources can be shared.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

package/dist-types/commands/StartQueryPlanningCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
+import { StartQueryPlanningRequest, StartQueryPlanningResponse } from "../models/models_0";
+export interface StartQueryPlanningCommandInput extends StartQueryPlanningRequest {
+}
+export interface StartQueryPlanningCommandOutput extends StartQueryPlanningResponse, __MetadataBearer {
+}
+/**
+ * <p>Submits a request to process a query statement.</p>
+ *
+ * 	        <p>This operation generates work units that can be retrieved with the <code>GetWorkUnits</code> operation as soon as the query state is WORKUNITS_AVAILABLE or FINISHED.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { LakeFormationClient, StartQueryPlanningCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
+ * // const { LakeFormationClient, StartQueryPlanningCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
+ * const client = new LakeFormationClient(config);
+ * const command = new StartQueryPlanningCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartQueryPlanningCommandInput} for command's `input` shape.
+ * @see {@link StartQueryPlanningCommandOutput} for command's `response` shape.
+ * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
+ *
+ */
+export declare class StartQueryPlanningCommand extends $Command<StartQueryPlanningCommandInput, StartQueryPlanningCommandOutput, LakeFormationClientResolvedConfig> {
+    readonly input: StartQueryPlanningCommandInput;
+    constructor(input: StartQueryPlanningCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartQueryPlanningCommandInput, StartQueryPlanningCommandOutput>;
+    private serialize;
+    private deserialize;
+}