@aws-sdk/client-lakeformation 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/ListPermissionsCommand.d.ts

@@ -1,37 +0,0 @@
-import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
-import { ListPermissionsRequest, ListPermissionsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListPermissionsCommandInput extends ListPermissionsRequest {
-}
-export interface ListPermissionsCommandOutput extends ListPermissionsResponse, __MetadataBearer {
-}
-/**
- * <p>Returns a list of the principal permissions on the resource, filtered by the permissions of the caller. For example, if you are granted an ALTER permission, you are able to see only the principal permissions for ALTER.</p>
- * 	        <p>This operation returns only those permissions that have been explicitly granted.</p>
- * 	        <p>For information about permissions, see <a href="https://docs-aws.amazon.com/lake-formation/latest/dg/security-data-access.html">Security and Access Control to Metadata and Data</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LakeFormationClient, ListPermissionsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
- * // const { LakeFormationClient, ListPermissionsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
- * const client = new LakeFormationClient(config);
- * const command = new ListPermissionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListPermissionsCommandInput} for command's `input` shape.
- * @see {@link ListPermissionsCommandOutput} for command's `response` shape.
- * @see {@link LakeFormationClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListPermissionsCommand extends $Command<ListPermissionsCommandInput, ListPermissionsCommandOutput, LakeFormationClientResolvedConfig> {
-    readonly input: ListPermissionsCommandInput;
-    constructor(input: ListPermissionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPermissionsCommandInput, ListPermissionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListResourcesCommand.d.ts

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

package/dist/types/ts3.4/commands/PutDataLakeSettingsCommand.d.ts

@@ -1,37 +0,0 @@
-import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
-import { PutDataLakeSettingsRequest, PutDataLakeSettingsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutDataLakeSettingsCommandInput extends PutDataLakeSettingsRequest {
-}
-export interface PutDataLakeSettingsCommandOutput extends PutDataLakeSettingsResponse, __MetadataBearer {
-}
-/**
- * <p>Sets the list of data lake administrators who have admin privileges on all resources managed by Lake Formation. For more information on admin privileges, see <a href="https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html">Granting Lake Formation Permissions</a>.</p>
- *
- * 	        <p>This API replaces the current list of data lake admins with the new list being passed. To add an admin, fetch the current list and add the new admin to that list and pass that list in this API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LakeFormationClient, PutDataLakeSettingsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
- * // const { LakeFormationClient, PutDataLakeSettingsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
- * const client = new LakeFormationClient(config);
- * const command = new PutDataLakeSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutDataLakeSettingsCommandInput} for command's `input` shape.
- * @see {@link PutDataLakeSettingsCommandOutput} for command's `response` shape.
- * @see {@link LakeFormationClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutDataLakeSettingsCommand extends $Command<PutDataLakeSettingsCommandInput, PutDataLakeSettingsCommandOutput, LakeFormationClientResolvedConfig> {
-    readonly input: PutDataLakeSettingsCommandInput;
-    constructor(input: PutDataLakeSettingsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutDataLakeSettingsCommandInput, PutDataLakeSettingsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/RegisterResourceCommand.d.ts

@@ -1,50 +0,0 @@
-import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
-import { RegisterResourceRequest, RegisterResourceResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface RegisterResourceCommandInput extends RegisterResourceRequest {
-}
-export interface RegisterResourceCommandOutput extends RegisterResourceResponse, __MetadataBearer {
-}
-/**
- * <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>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>
- *             <code>ResourceArn = arn:aws:s3:::my-bucket
- * UseServiceLinkedRole = true</code>
- *          </p>
- *
- * 	        <p>If <code>UseServiceLinkedRole</code> is not set to true, you must provide or set the <code>RoleArn</code>:</p>
- *
- *          <p>
- *             <code>arn:aws:iam::12345:role/my-data-access-role</code>
- *          </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LakeFormationClient, RegisterResourceCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
- * // const { LakeFormationClient, RegisterResourceCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
- * const client = new LakeFormationClient(config);
- * const command = new RegisterResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RegisterResourceCommandInput} for command's `input` shape.
- * @see {@link RegisterResourceCommandOutput} for command's `response` shape.
- * @see {@link LakeFormationClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class RegisterResourceCommand extends $Command<RegisterResourceCommandInput, RegisterResourceCommandOutput, LakeFormationClientResolvedConfig> {
-    readonly input: RegisterResourceCommandInput;
-    constructor(input: RegisterResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterResourceCommandInput, RegisterResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/RemoveLFTagsFromResourceCommand.d.ts

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

package/dist/types/ts3.4/commands/RevokePermissionsCommand.d.ts

@@ -1,35 +0,0 @@
-import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
-import { RevokePermissionsRequest, RevokePermissionsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface RevokePermissionsCommandInput extends RevokePermissionsRequest {
-}
-export interface RevokePermissionsCommandOutput extends RevokePermissionsResponse, __MetadataBearer {
-}
-/**
- * <p>Revokes permissions to the principal to access metadata in the Data Catalog and data organized in underlying data storage such as Amazon S3.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LakeFormationClient, RevokePermissionsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
- * // const { LakeFormationClient, RevokePermissionsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
- * const client = new LakeFormationClient(config);
- * const command = new RevokePermissionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RevokePermissionsCommandInput} for command's `input` shape.
- * @see {@link RevokePermissionsCommandOutput} for command's `response` shape.
- * @see {@link LakeFormationClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class RevokePermissionsCommand extends $Command<RevokePermissionsCommandInput, RevokePermissionsCommandOutput, LakeFormationClientResolvedConfig> {
-    readonly input: RevokePermissionsCommandInput;
-    constructor(input: RevokePermissionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RevokePermissionsCommandInput, RevokePermissionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/SearchDatabasesByLFTagsCommand.d.ts

@@ -1,35 +0,0 @@
-import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
-import { SearchDatabasesByLFTagsRequest, SearchDatabasesByLFTagsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface SearchDatabasesByLFTagsCommandInput extends SearchDatabasesByLFTagsRequest {
-}
-export interface SearchDatabasesByLFTagsCommandOutput extends SearchDatabasesByLFTagsResponse, __MetadataBearer {
-}
-/**
- * <p>This operation allows a search on <code>DATABASE</code> resources by <code>TagCondition</code>. This operation is used by admins who want to grant user permissions on certain <code>TagConditions</code>. Before making a grant, the admin can use <code>SearchDatabasesByTags</code> to find all resources where the given <code>TagConditions</code> 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
- * import { LakeFormationClient, SearchDatabasesByLFTagsCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
- * // const { LakeFormationClient, SearchDatabasesByLFTagsCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
- * const client = new LakeFormationClient(config);
- * const command = new SearchDatabasesByLFTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SearchDatabasesByLFTagsCommandInput} for command's `input` shape.
- * @see {@link SearchDatabasesByLFTagsCommandOutput} for command's `response` shape.
- * @see {@link LakeFormationClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class SearchDatabasesByLFTagsCommand extends $Command<SearchDatabasesByLFTagsCommandInput, SearchDatabasesByLFTagsCommandOutput, LakeFormationClientResolvedConfig> {
-    readonly input: SearchDatabasesByLFTagsCommandInput;
-    constructor(input: SearchDatabasesByLFTagsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SearchDatabasesByLFTagsCommandInput, SearchDatabasesByLFTagsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/SearchTablesByLFTagsCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdateLFTagCommand.d.ts

@@ -1,35 +0,0 @@
-import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
-import { UpdateLFTagRequest, UpdateLFTagResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateLFTagCommandInput extends UpdateLFTagRequest {
-}
-export interface UpdateLFTagCommandOutput extends UpdateLFTagResponse, __MetadataBearer {
-}
-/**
- * <p>Updates the list of possible values for the specified tag key. If the tag does not exist, the operation throws an EntityNotFoundException. The values in the delete key values will be deleted from list of possible values. If any value in the delete key values is attached to a resource, then API errors out with a 400 Exception - "Update not allowed". Untag the attribute before deleting the tag key's value.  </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LakeFormationClient, UpdateLFTagCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
- * // const { LakeFormationClient, UpdateLFTagCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
- * const client = new LakeFormationClient(config);
- * const command = new UpdateLFTagCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateLFTagCommandInput} for command's `input` shape.
- * @see {@link UpdateLFTagCommandOutput} for command's `response` shape.
- * @see {@link LakeFormationClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateLFTagCommand extends $Command<UpdateLFTagCommandInput, UpdateLFTagCommandOutput, LakeFormationClientResolvedConfig> {
-    readonly input: UpdateLFTagCommandInput;
-    constructor(input: UpdateLFTagCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateLFTagCommandInput, UpdateLFTagCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/UpdateResourceCommand.d.ts

@@ -1,35 +0,0 @@
-import { LakeFormationClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../LakeFormationClient";
-import { UpdateResourceRequest, UpdateResourceResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateResourceCommandInput extends UpdateResourceRequest {
-}
-export interface UpdateResourceCommandOutput extends UpdateResourceResponse, __MetadataBearer {
-}
-/**
- * <p>Updates the data access role used for vending access to the given (registered) resource in AWS Lake Formation. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LakeFormationClient, UpdateResourceCommand } from "@aws-sdk/client-lakeformation"; // ES Modules import
- * // const { LakeFormationClient, UpdateResourceCommand } = require("@aws-sdk/client-lakeformation"); // CommonJS import
- * const client = new LakeFormationClient(config);
- * const command = new UpdateResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateResourceCommandInput} for command's `input` shape.
- * @see {@link UpdateResourceCommandOutput} for command's `response` shape.
- * @see {@link LakeFormationClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateResourceCommand extends $Command<UpdateResourceCommandInput, UpdateResourceCommandOutput, LakeFormationClientResolvedConfig> {
-    readonly input: UpdateResourceCommandInput;
-    constructor(input: UpdateResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LakeFormationClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateResourceCommandInput, UpdateResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}