@aws-sdk/client-lakeformation 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { CancelTransactionRequest, CancelTransactionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CancelTransactionCommand}.
  */
 export interface CancelTransactionCommandInput extends CancelTransactionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CancelTransactionCommand}.
  */
 export interface CancelTransactionCommandOutput extends CancelTransactionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Attempts to cancel the specified transaction. Returns an exception if the transaction was previously committed.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CancelTransactionCommandOutput extends CancelTransactionRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param CancelTransactionCommandInput - {@link CancelTransactionCommandInput}
+ * @returns {@link CancelTransactionCommandOutput}
  * @see {@link CancelTransactionCommandInput} for command's `input` shape.
  * @see {@link CancelTransactionCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -55,11 +62,20 @@ export interface CancelTransactionCommandOutput extends CancelTransactionRespons
 export declare class CancelTransactionCommand extends $Command<CancelTransactionCommandInput, CancelTransactionCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: CancelTransactionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CancelTransactionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelTransactionCommandInput, CancelTransactionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { CommitTransactionRequest, CommitTransactionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CommitTransactionCommand}.
  */
 export interface CommitTransactionCommandInput extends CommitTransactionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CommitTransactionCommand}.
  */
 export interface CommitTransactionCommandOutput extends CommitTransactionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Attempts to commit the specified transaction. Returns an exception if the transaction was previously aborted. This API action is idempotent if called multiple times for the same transaction.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CommitTransactionCommandOutput extends CommitTransactionRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param CommitTransactionCommandInput - {@link CommitTransactionCommandInput}
+ * @returns {@link CommitTransactionCommandOutput}
  * @see {@link CommitTransactionCommandInput} for command's `input` shape.
  * @see {@link CommitTransactionCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -52,11 +59,20 @@ export interface CommitTransactionCommandOutput extends CommitTransactionRespons
 export declare class CommitTransactionCommand extends $Command<CommitTransactionCommandInput, CommitTransactionCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: CommitTransactionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CommitTransactionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CommitTransactionCommandInput, CommitTransactionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { CreateDataCellsFilterRequest, CreateDataCellsFilterResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateDataCellsFilterCommand}.
  */
 export interface CreateDataCellsFilterCommandInput extends CreateDataCellsFilterRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateDataCellsFilterCommand}.
  */
 export interface CreateDataCellsFilterCommandOutput extends CreateDataCellsFilterResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a data cell filter to allow one to grant access to certain columns on certain rows.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateDataCellsFilterCommandOutput extends CreateDataCellsFilte
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateDataCellsFilterCommandInput - {@link CreateDataCellsFilterCommandInput}
+ * @returns {@link CreateDataCellsFilterCommandOutput}
  * @see {@link CreateDataCellsFilterCommandInput} for command's `input` shape.
  * @see {@link CreateDataCellsFilterCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -55,11 +62,20 @@ export interface CreateDataCellsFilterCommandOutput extends CreateDataCellsFilte
 export declare class CreateDataCellsFilterCommand extends $Command<CreateDataCellsFilterCommandInput, CreateDataCellsFilterCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: CreateDataCellsFilterCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateDataCellsFilterCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDataCellsFilterCommandInput, CreateDataCellsFilterCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { CreateLFTagRequest, CreateLFTagResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link CreateLFTagCommand}.
  */
 export interface CreateLFTagCommandInput extends CreateLFTagRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLFTagCommand}.
  */
 export interface CreateLFTagCommandOutput extends CreateLFTagResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an LF-tag with the specified name and values.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateLFTagCommandOutput extends CreateLFTagResponse, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLFTagCommandInput - {@link CreateLFTagCommandInput}
+ * @returns {@link CreateLFTagCommandOutput}
  * @see {@link CreateLFTagCommandInput} for command's `input` shape.
  * @see {@link CreateLFTagCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -52,11 +59,20 @@ export interface CreateLFTagCommandOutput extends CreateLFTagResponse, __Metadat
 export declare class CreateLFTagCommand extends $Command<CreateLFTagCommandInput, CreateLFTagCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: CreateLFTagCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLFTagCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLFTagCommandInput, CreateLFTagCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { DeleteDataCellsFilterRequest, DeleteDataCellsFilterResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteDataCellsFilterCommand}.
  */
 export interface DeleteDataCellsFilterCommandInput extends DeleteDataCellsFilterRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteDataCellsFilterCommand}.
  */
 export interface DeleteDataCellsFilterCommandOutput extends DeleteDataCellsFilterResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a data cell filter.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteDataCellsFilterCommandOutput extends DeleteDataCellsFilte
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteDataCellsFilterCommandInput - {@link DeleteDataCellsFilterCommandInput}
+ * @returns {@link DeleteDataCellsFilterCommandOutput}
  * @see {@link DeleteDataCellsFilterCommandInput} for command's `input` shape.
  * @see {@link DeleteDataCellsFilterCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -49,11 +56,20 @@ export interface DeleteDataCellsFilterCommandOutput extends DeleteDataCellsFilte
 export declare class DeleteDataCellsFilterCommand extends $Command<DeleteDataCellsFilterCommandInput, DeleteDataCellsFilterCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: DeleteDataCellsFilterCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteDataCellsFilterCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDataCellsFilterCommandInput, DeleteDataCellsFilterCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { DeleteLFTagRequest, DeleteLFTagResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteLFTagCommand}.
  */
 export interface DeleteLFTagCommandInput extends DeleteLFTagRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteLFTagCommand}.
  */
 export interface DeleteLFTagCommandOutput extends DeleteLFTagResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified LF-tag given a key name. If the input parameter tag key was not found, then the operation will throw an exception. When you delete an LF-tag, the <code>LFTagPolicy</code> attached to the LF-tag becomes invalid. If the deleted LF-tag was still assigned to any resource, the tag policy attach to the deleted LF-tag will no longer be applied to the resource.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteLFTagCommandOutput extends DeleteLFTagResponse, __Metadat
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteLFTagCommandInput - {@link DeleteLFTagCommandInput}
+ * @returns {@link DeleteLFTagCommandOutput}
  * @see {@link DeleteLFTagCommandInput} for command's `input` shape.
  * @see {@link DeleteLFTagCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -49,11 +56,20 @@ export interface DeleteLFTagCommandOutput extends DeleteLFTagResponse, __Metadat
 export declare class DeleteLFTagCommand extends $Command<DeleteLFTagCommandInput, DeleteLFTagCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: DeleteLFTagCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteLFTagCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteLFTagCommandInput, DeleteLFTagCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { DeleteObjectsOnCancelRequest, DeleteObjectsOnCancelResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeleteObjectsOnCancelCommand}.
  */
 export interface DeleteObjectsOnCancelCommandInput extends DeleteObjectsOnCancelRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteObjectsOnCancelCommand}.
  */
 export interface DeleteObjectsOnCancelCommandOutput extends DeleteObjectsOnCancelResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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>
@@ -32,6 +37,8 @@ export interface DeleteObjectsOnCancelCommandOutput extends DeleteObjectsOnCance
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteObjectsOnCancelCommandInput - {@link DeleteObjectsOnCancelCommandInput}
+ * @returns {@link DeleteObjectsOnCancelCommandOutput}
  * @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.
@@ -65,11 +72,20 @@ export interface DeleteObjectsOnCancelCommandOutput extends DeleteObjectsOnCance
 export declare class DeleteObjectsOnCancelCommand extends $Command<DeleteObjectsOnCancelCommandInput, DeleteObjectsOnCancelCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: DeleteObjectsOnCancelCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteObjectsOnCancelCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteObjectsOnCancelCommandInput, DeleteObjectsOnCancelCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { DeregisterResourceRequest, DeregisterResourceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DeregisterResourceCommand}.
  */
 export interface DeregisterResourceCommandInput extends DeregisterResourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeregisterResourceCommand}.
  */
 export interface DeregisterResourceCommandOutput extends DeregisterResourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deregisters the resource as managed by the Data Catalog.</p>
  *          <p>When you deregister a path, Lake Formation removes the path from the inline policy attached to your service-linked role.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeregisterResourceCommandOutput extends DeregisterResourceRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param DeregisterResourceCommandInput - {@link DeregisterResourceCommandInput}
+ * @returns {@link DeregisterResourceCommandOutput}
  * @see {@link DeregisterResourceCommandInput} for command's `input` shape.
  * @see {@link DeregisterResourceCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -47,11 +54,20 @@ export interface DeregisterResourceCommandOutput extends DeregisterResourceRespo
 export declare class DeregisterResourceCommand extends $Command<DeregisterResourceCommandInput, DeregisterResourceCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: DeregisterResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeregisterResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeregisterResourceCommandInput, DeregisterResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { DescribeResourceRequest, DescribeResourceResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeResourceCommand}.
  */
 export interface DescribeResourceCommandInput extends DescribeResourceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeResourceCommand}.
  */
 export interface DescribeResourceCommandOutput extends DescribeResourceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface DescribeResourceCommandOutput extends DescribeResourceResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeResourceCommandInput - {@link DescribeResourceCommandInput}
+ * @returns {@link DescribeResourceCommandOutput}
  * @see {@link DescribeResourceCommandInput} for command's `input` shape.
  * @see {@link DescribeResourceCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -46,11 +53,20 @@ export interface DescribeResourceCommandOutput extends DescribeResourceResponse,
 export declare class DescribeResourceCommand extends $Command<DescribeResourceCommandInput, DescribeResourceCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: DescribeResourceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeResourceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeResourceCommandInput, DescribeResourceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { DescribeTransactionRequest, DescribeTransactionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link DescribeTransactionCommand}.
  */
 export interface DescribeTransactionCommandInput extends DescribeTransactionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DescribeTransactionCommand}.
  */
 export interface DescribeTransactionCommandOutput extends DescribeTransactionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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.
@@ -25,6 +30,8 @@ export interface DescribeTransactionCommandOutput extends DescribeTransactionRes
  * const response = await client.send(command);
  * ```
  *
+ * @param DescribeTransactionCommandInput - {@link DescribeTransactionCommandInput}
+ * @returns {@link DescribeTransactionCommandOutput}
  * @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.
@@ -46,11 +53,20 @@ export interface DescribeTransactionCommandOutput extends DescribeTransactionRes
 export declare class DescribeTransactionCommand extends $Command<DescribeTransactionCommandInput, DescribeTransactionCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: DescribeTransactionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DescribeTransactionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTransactionCommandInput, DescribeTransactionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { ExtendTransactionRequest, ExtendTransactionResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link ExtendTransactionCommand}.
  */
 export interface ExtendTransactionCommandInput extends ExtendTransactionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link ExtendTransactionCommand}.
  */
 export interface ExtendTransactionCommandOutput extends ExtendTransactionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <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
@@ -26,6 +31,8 @@ export interface ExtendTransactionCommandOutput extends ExtendTransactionRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param ExtendTransactionCommandInput - {@link ExtendTransactionCommandInput}
+ * @returns {@link ExtendTransactionCommandOutput}
  * @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.
@@ -56,11 +63,20 @@ export interface ExtendTransactionCommandOutput extends ExtendTransactionRespons
 export declare class ExtendTransactionCommand extends $Command<ExtendTransactionCommandInput, ExtendTransactionCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: ExtendTransactionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: ExtendTransactionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ExtendTransactionCommandInput, ExtendTransactionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { GetDataCellsFilterRequest, GetDataCellsFilterResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetDataCellsFilterCommand}.
  */
 export interface GetDataCellsFilterCommandInput extends GetDataCellsFilterRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetDataCellsFilterCommand}.
  */
 export interface GetDataCellsFilterCommandOutput extends GetDataCellsFilterResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Returns a data cells filter.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GetDataCellsFilterCommandOutput extends GetDataCellsFilterRespo
  * const response = await client.send(command);
  * ```
  *
+ * @param GetDataCellsFilterCommandInput - {@link GetDataCellsFilterCommandInput}
+ * @returns {@link GetDataCellsFilterCommandOutput}
  * @see {@link GetDataCellsFilterCommandInput} for command's `input` shape.
  * @see {@link GetDataCellsFilterCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -49,11 +56,20 @@ export interface GetDataCellsFilterCommandOutput extends GetDataCellsFilterRespo
 export declare class GetDataCellsFilterCommand extends $Command<GetDataCellsFilterCommandInput, GetDataCellsFilterCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: GetDataCellsFilterCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetDataCellsFilterCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDataCellsFilterCommandInput, GetDataCellsFilterCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
 import { GetDataLakeSettingsRequest, GetDataLakeSettingsResponse } from "../models/models_0";
 /**
+ * @public
+ *
  * The input for {@link GetDataLakeSettingsCommand}.
  */
 export interface GetDataLakeSettingsCommandInput extends GetDataLakeSettingsRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link GetDataLakeSettingsCommand}.
  */
 export interface GetDataLakeSettingsCommandOutput extends GetDataLakeSettingsResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Retrieves the list of the data lake administrators of a Lake Formation-managed data lake. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface GetDataLakeSettingsCommandOutput extends GetDataLakeSettingsRes
  * const response = await client.send(command);
  * ```
  *
+ * @param GetDataLakeSettingsCommandInput - {@link GetDataLakeSettingsCommandInput}
+ * @returns {@link GetDataLakeSettingsCommandOutput}
  * @see {@link GetDataLakeSettingsCommandInput} for command's `input` shape.
  * @see {@link GetDataLakeSettingsCommandOutput} for command's `response` shape.
  * @see {@link LakeFormationClientResolvedConfig | config} for LakeFormationClient's `config` shape.
@@ -43,11 +50,20 @@ export interface GetDataLakeSettingsCommandOutput extends GetDataLakeSettingsRes
 export declare class GetDataLakeSettingsCommand extends $Command<GetDataLakeSettingsCommandInput, GetDataLakeSettingsCommandOutput, LakeFormationClientResolvedConfig> {
     readonly input: GetDataLakeSettingsCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: GetDataLakeSettingsCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDataLakeSettingsCommandInput, GetDataLakeSettingsCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }