@aws-sdk/client-lakeformation 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1741 @@
+
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { Readable } from "stream";
+import { LakeFormationServiceException as __BaseException } from "./LakeFormationServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export interface LFTagPair {
+    
+    CatalogId?: string;
+    
+    TagKey: string | undefined;
+    
+    TagValues: string[] | undefined;
+}
+export declare namespace LFTagPair {
+    
+    const filterSensitiveLog: (obj: LFTagPair) => any;
+}
+
+export interface CatalogResource {
+}
+export declare namespace CatalogResource {
+    
+    const filterSensitiveLog: (obj: CatalogResource) => any;
+}
+
+export interface DatabaseResource {
+    
+    CatalogId?: string;
+    
+    Name: string | undefined;
+}
+export declare namespace DatabaseResource {
+    
+    const filterSensitiveLog: (obj: DatabaseResource) => any;
+}
+
+export interface DataCellsFilterResource {
+    
+    TableCatalogId?: string;
+    
+    DatabaseName?: string;
+    
+    TableName?: string;
+    
+    Name?: string;
+}
+export declare namespace DataCellsFilterResource {
+    
+    const filterSensitiveLog: (obj: DataCellsFilterResource) => any;
+}
+
+export interface DataLocationResource {
+    
+    CatalogId?: string;
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace DataLocationResource {
+    
+    const filterSensitiveLog: (obj: DataLocationResource) => any;
+}
+
+export interface LFTagKeyResource {
+    
+    CatalogId?: string;
+    
+    TagKey: string | undefined;
+    
+    TagValues: string[] | undefined;
+}
+export declare namespace LFTagKeyResource {
+    
+    const filterSensitiveLog: (obj: LFTagKeyResource) => any;
+}
+
+export interface LFTag {
+    
+    TagKey: string | undefined;
+    
+    TagValues: string[] | undefined;
+}
+export declare namespace LFTag {
+    
+    const filterSensitiveLog: (obj: LFTag) => any;
+}
+export declare enum ResourceType {
+    DATABASE = "DATABASE",
+    TABLE = "TABLE"
+}
+
+export interface LFTagPolicyResource {
+    
+    CatalogId?: string;
+    
+    ResourceType: ResourceType | string | undefined;
+    
+    Expression: LFTag[] | undefined;
+}
+export declare namespace LFTagPolicyResource {
+    
+    const filterSensitiveLog: (obj: LFTagPolicyResource) => any;
+}
+
+export interface TableWildcard {
+}
+export declare namespace TableWildcard {
+    
+    const filterSensitiveLog: (obj: TableWildcard) => any;
+}
+
+export interface TableResource {
+    
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    Name?: string;
+    
+    TableWildcard?: TableWildcard;
+}
+export declare namespace TableResource {
+    
+    const filterSensitiveLog: (obj: TableResource) => any;
+}
+
+export interface ColumnWildcard {
+    
+    ExcludedColumnNames?: string[];
+}
+export declare namespace ColumnWildcard {
+    
+    const filterSensitiveLog: (obj: ColumnWildcard) => any;
+}
+
+export interface TableWithColumnsResource {
+    
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    Name: string | undefined;
+    
+    ColumnNames?: string[];
+    
+    ColumnWildcard?: ColumnWildcard;
+}
+export declare namespace TableWithColumnsResource {
+    
+    const filterSensitiveLog: (obj: TableWithColumnsResource) => any;
+}
+
+export interface Resource {
+    
+    Catalog?: CatalogResource;
+    
+    Database?: DatabaseResource;
+    
+    Table?: TableResource;
+    
+    TableWithColumns?: TableWithColumnsResource;
+    
+    DataLocation?: DataLocationResource;
+    
+    DataCellsFilter?: DataCellsFilterResource;
+    
+    LFTag?: LFTagKeyResource;
+    
+    LFTagPolicy?: LFTagPolicyResource;
+}
+export declare namespace Resource {
+    
+    const filterSensitiveLog: (obj: Resource) => any;
+}
+export interface AddLFTagsToResourceRequest {
+    
+    CatalogId?: string;
+    
+    Resource: Resource | undefined;
+    
+    LFTags: LFTagPair[] | undefined;
+}
+export declare namespace AddLFTagsToResourceRequest {
+    
+    const filterSensitiveLog: (obj: AddLFTagsToResourceRequest) => any;
+}
+
+export interface ErrorDetail {
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace ErrorDetail {
+    
+    const filterSensitiveLog: (obj: ErrorDetail) => any;
+}
+
+export interface LFTagError {
+    
+    LFTag?: LFTagPair;
+    
+    Error?: ErrorDetail;
+}
+export declare namespace LFTagError {
+    
+    const filterSensitiveLog: (obj: LFTagError) => any;
+}
+export interface AddLFTagsToResourceResponse {
+    
+    Failures?: LFTagError[];
+}
+export declare namespace AddLFTagsToResourceResponse {
+    
+    const filterSensitiveLog: (obj: AddLFTagsToResourceResponse) => any;
+}
+
+export declare class ConcurrentModificationException extends __BaseException {
+    readonly name: "ConcurrentModificationException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConcurrentModificationException, __BaseException>);
+}
+
+export declare class EntityNotFoundException extends __BaseException {
+    readonly name: "EntityNotFoundException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EntityNotFoundException, __BaseException>);
+}
+
+export declare class InternalServiceException extends __BaseException {
+    readonly name: "InternalServiceException";
+    readonly $fault: "server";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServiceException, __BaseException>);
+}
+
+export declare class InvalidInputException extends __BaseException {
+    readonly name: "InvalidInputException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidInputException, __BaseException>);
+}
+
+export declare class OperationTimeoutException extends __BaseException {
+    readonly name: "OperationTimeoutException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OperationTimeoutException, __BaseException>);
+}
+
+export interface AddObjectInput {
+    
+    Uri: string | undefined;
+    
+    ETag: string | undefined;
+    
+    Size: number | undefined;
+    
+    PartitionValues?: string[];
+}
+export declare namespace AddObjectInput {
+    
+    const filterSensitiveLog: (obj: AddObjectInput) => any;
+}
+
+export interface AllRowsWildcard {
+}
+export declare namespace AllRowsWildcard {
+    
+    const filterSensitiveLog: (obj: AllRowsWildcard) => any;
+}
+
+export declare class AlreadyExistsException extends __BaseException {
+    readonly name: "AlreadyExistsException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AlreadyExistsException, __BaseException>);
+}
+
+export interface AuditContext {
+    
+    AdditionalAuditContext?: string;
+}
+export declare namespace AuditContext {
+    
+    const filterSensitiveLog: (obj: AuditContext) => any;
+}
+export declare enum Permission {
+    ALL = "ALL",
+    ALTER = "ALTER",
+    ALTER_TAG = "ALTER_TAG",
+    ASSOCIATE_TAG = "ASSOCIATE_TAG",
+    CREATE_DATABASE = "CREATE_DATABASE",
+    CREATE_TABLE = "CREATE_TABLE",
+    CREATE_TAG = "CREATE_TAG",
+    DATA_LOCATION_ACCESS = "DATA_LOCATION_ACCESS",
+    DELETE = "DELETE",
+    DELETE_TAG = "DELETE_TAG",
+    DESCRIBE = "DESCRIBE",
+    DESCRIBE_TAG = "DESCRIBE_TAG",
+    DROP = "DROP",
+    INSERT = "INSERT",
+    SELECT = "SELECT"
+}
+
+export interface DataLakePrincipal {
+    
+    DataLakePrincipalIdentifier?: string;
+}
+export declare namespace DataLakePrincipal {
+    
+    const filterSensitiveLog: (obj: DataLakePrincipal) => any;
+}
+
+export interface BatchPermissionsRequestEntry {
+    
+    Id: string | undefined;
+    
+    Principal?: DataLakePrincipal;
+    
+    Resource?: Resource;
+    
+    Permissions?: (Permission | string)[];
+    
+    PermissionsWithGrantOption?: (Permission | string)[];
+}
+export declare namespace BatchPermissionsRequestEntry {
+    
+    const filterSensitiveLog: (obj: BatchPermissionsRequestEntry) => any;
+}
+export interface BatchGrantPermissionsRequest {
+    
+    CatalogId?: string;
+    
+    Entries: BatchPermissionsRequestEntry[] | undefined;
+}
+export declare namespace BatchGrantPermissionsRequest {
+    
+    const filterSensitiveLog: (obj: BatchGrantPermissionsRequest) => any;
+}
+
+export interface BatchPermissionsFailureEntry {
+    
+    RequestEntry?: BatchPermissionsRequestEntry;
+    
+    Error?: ErrorDetail;
+}
+export declare namespace BatchPermissionsFailureEntry {
+    
+    const filterSensitiveLog: (obj: BatchPermissionsFailureEntry) => any;
+}
+export interface BatchGrantPermissionsResponse {
+    
+    Failures?: BatchPermissionsFailureEntry[];
+}
+export declare namespace BatchGrantPermissionsResponse {
+    
+    const filterSensitiveLog: (obj: BatchGrantPermissionsResponse) => any;
+}
+export interface BatchRevokePermissionsRequest {
+    
+    CatalogId?: string;
+    
+    Entries: BatchPermissionsRequestEntry[] | undefined;
+}
+export declare namespace BatchRevokePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: BatchRevokePermissionsRequest) => any;
+}
+export interface BatchRevokePermissionsResponse {
+    
+    Failures?: BatchPermissionsFailureEntry[];
+}
+export declare namespace BatchRevokePermissionsResponse {
+    
+    const filterSensitiveLog: (obj: BatchRevokePermissionsResponse) => any;
+}
+export interface CancelTransactionRequest {
+    
+    TransactionId: string | undefined;
+}
+export declare namespace CancelTransactionRequest {
+    
+    const filterSensitiveLog: (obj: CancelTransactionRequest) => any;
+}
+export interface CancelTransactionResponse {
+}
+export declare namespace CancelTransactionResponse {
+    
+    const filterSensitiveLog: (obj: CancelTransactionResponse) => any;
+}
+
+export declare class TransactionCommitInProgressException extends __BaseException {
+    readonly name: "TransactionCommitInProgressException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TransactionCommitInProgressException, __BaseException>);
+}
+
+export declare class TransactionCommittedException extends __BaseException {
+    readonly name: "TransactionCommittedException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TransactionCommittedException, __BaseException>);
+}
+export interface CommitTransactionRequest {
+    
+    TransactionId: string | undefined;
+}
+export declare namespace CommitTransactionRequest {
+    
+    const filterSensitiveLog: (obj: CommitTransactionRequest) => any;
+}
+export declare enum TransactionStatus {
+    ABORTED = "ABORTED",
+    ACTIVE = "ACTIVE",
+    COMMITTED = "COMMITTED",
+    COMMIT_IN_PROGRESS = "COMMIT_IN_PROGRESS"
+}
+export interface CommitTransactionResponse {
+    
+    TransactionStatus?: TransactionStatus | string;
+}
+export declare namespace CommitTransactionResponse {
+    
+    const filterSensitiveLog: (obj: CommitTransactionResponse) => any;
+}
+
+export declare class TransactionCanceledException extends __BaseException {
+    readonly name: "TransactionCanceledException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TransactionCanceledException, __BaseException>);
+}
+
+export interface RowFilter {
+    
+    FilterExpression?: string;
+    
+    AllRowsWildcard?: AllRowsWildcard;
+}
+export declare namespace RowFilter {
+    
+    const filterSensitiveLog: (obj: RowFilter) => any;
+}
+
+export interface DataCellsFilter {
+    
+    TableCatalogId: string | undefined;
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    Name: string | undefined;
+    
+    RowFilter?: RowFilter;
+    
+    ColumnNames?: string[];
+    
+    ColumnWildcard?: ColumnWildcard;
+}
+export declare namespace DataCellsFilter {
+    
+    const filterSensitiveLog: (obj: DataCellsFilter) => any;
+}
+export interface CreateDataCellsFilterRequest {
+    
+    TableData: DataCellsFilter | undefined;
+}
+export declare namespace CreateDataCellsFilterRequest {
+    
+    const filterSensitiveLog: (obj: CreateDataCellsFilterRequest) => any;
+}
+export interface CreateDataCellsFilterResponse {
+}
+export declare namespace CreateDataCellsFilterResponse {
+    
+    const filterSensitiveLog: (obj: CreateDataCellsFilterResponse) => any;
+}
+
+export declare class ResourceNumberLimitExceededException extends __BaseException {
+    readonly name: "ResourceNumberLimitExceededException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNumberLimitExceededException, __BaseException>);
+}
+export interface CreateLFTagRequest {
+    
+    CatalogId?: string;
+    
+    TagKey: string | undefined;
+    
+    TagValues: string[] | undefined;
+}
+export declare namespace CreateLFTagRequest {
+    
+    const filterSensitiveLog: (obj: CreateLFTagRequest) => any;
+}
+export interface CreateLFTagResponse {
+}
+export declare namespace CreateLFTagResponse {
+    
+    const filterSensitiveLog: (obj: CreateLFTagResponse) => any;
+}
+export interface DeleteDataCellsFilterRequest {
+    
+    TableCatalogId?: string;
+    
+    DatabaseName?: string;
+    
+    TableName?: string;
+    
+    Name?: string;
+}
+export declare namespace DeleteDataCellsFilterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDataCellsFilterRequest) => any;
+}
+export interface DeleteDataCellsFilterResponse {
+}
+export declare namespace DeleteDataCellsFilterResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDataCellsFilterResponse) => any;
+}
+export interface DeleteLFTagRequest {
+    
+    CatalogId?: string;
+    
+    TagKey: string | undefined;
+}
+export declare namespace DeleteLFTagRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLFTagRequest) => any;
+}
+export interface DeleteLFTagResponse {
+}
+export declare namespace DeleteLFTagResponse {
+    
+    const filterSensitiveLog: (obj: DeleteLFTagResponse) => any;
+}
+
+export interface VirtualObject {
+    
+    Uri: string | undefined;
+    
+    ETag?: string;
+}
+export declare namespace VirtualObject {
+    
+    const filterSensitiveLog: (obj: VirtualObject) => any;
+}
+export interface DeleteObjectsOnCancelRequest {
+    
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    TransactionId: string | undefined;
+    
+    Objects: VirtualObject[] | undefined;
+}
+export declare namespace DeleteObjectsOnCancelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteObjectsOnCancelRequest) => any;
+}
+export interface DeleteObjectsOnCancelResponse {
+}
+export declare namespace DeleteObjectsOnCancelResponse {
+    
+    const filterSensitiveLog: (obj: DeleteObjectsOnCancelResponse) => any;
+}
+
+export declare class ResourceNotReadyException extends __BaseException {
+    readonly name: "ResourceNotReadyException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotReadyException, __BaseException>);
+}
+export interface DeregisterResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace DeregisterResourceRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterResourceRequest) => any;
+}
+export interface DeregisterResourceResponse {
+}
+export declare namespace DeregisterResourceResponse {
+    
+    const filterSensitiveLog: (obj: DeregisterResourceResponse) => any;
+}
+export interface DescribeResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace DescribeResourceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeResourceRequest) => any;
+}
+
+export interface ResourceInfo {
+    
+    ResourceArn?: string;
+    
+    RoleArn?: string;
+    
+    LastModified?: Date;
+}
+export declare namespace ResourceInfo {
+    
+    const filterSensitiveLog: (obj: ResourceInfo) => any;
+}
+export interface DescribeResourceResponse {
+    
+    ResourceInfo?: ResourceInfo;
+}
+export declare namespace DescribeResourceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeResourceResponse) => any;
+}
+export interface DescribeTransactionRequest {
+    
+    TransactionId: string | undefined;
+}
+export declare namespace DescribeTransactionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTransactionRequest) => any;
+}
+
+export interface TransactionDescription {
+    
+    TransactionId?: string;
+    
+    TransactionStatus?: TransactionStatus | string;
+    
+    TransactionStartTime?: Date;
+    
+    TransactionEndTime?: Date;
+}
+export declare namespace TransactionDescription {
+    
+    const filterSensitiveLog: (obj: TransactionDescription) => any;
+}
+export interface DescribeTransactionResponse {
+    
+    TransactionDescription?: TransactionDescription;
+}
+export declare namespace DescribeTransactionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeTransactionResponse) => any;
+}
+export interface ExtendTransactionRequest {
+    
+    TransactionId?: string;
+}
+export declare namespace ExtendTransactionRequest {
+    
+    const filterSensitiveLog: (obj: ExtendTransactionRequest) => any;
+}
+export interface ExtendTransactionResponse {
+}
+export declare namespace ExtendTransactionResponse {
+    
+    const filterSensitiveLog: (obj: ExtendTransactionResponse) => any;
+}
+export interface GetDataLakeSettingsRequest {
+    
+    CatalogId?: string;
+}
+export declare namespace GetDataLakeSettingsRequest {
+    
+    const filterSensitiveLog: (obj: GetDataLakeSettingsRequest) => any;
+}
+
+export interface PrincipalPermissions {
+    
+    Principal?: DataLakePrincipal;
+    
+    Permissions?: (Permission | string)[];
+}
+export declare namespace PrincipalPermissions {
+    
+    const filterSensitiveLog: (obj: PrincipalPermissions) => any;
+}
+
+export interface DataLakeSettings {
+    
+    DataLakeAdmins?: DataLakePrincipal[];
+    
+    CreateDatabaseDefaultPermissions?: PrincipalPermissions[];
+    
+    CreateTableDefaultPermissions?: PrincipalPermissions[];
+    
+    TrustedResourceOwners?: string[];
+    
+    AllowExternalDataFiltering?: boolean;
+    
+    ExternalDataFilteringAllowList?: DataLakePrincipal[];
+    
+    AuthorizedSessionTagValueList?: string[];
+}
+export declare namespace DataLakeSettings {
+    
+    const filterSensitiveLog: (obj: DataLakeSettings) => any;
+}
+export interface GetDataLakeSettingsResponse {
+    
+    DataLakeSettings?: DataLakeSettings;
+}
+export declare namespace GetDataLakeSettingsResponse {
+    
+    const filterSensitiveLog: (obj: GetDataLakeSettingsResponse) => any;
+}
+export interface GetEffectivePermissionsForPathRequest {
+    
+    CatalogId?: string;
+    
+    ResourceArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace GetEffectivePermissionsForPathRequest {
+    
+    const filterSensitiveLog: (obj: GetEffectivePermissionsForPathRequest) => any;
+}
+
+export interface DetailsMap {
+    
+    ResourceShare?: string[];
+}
+export declare namespace DetailsMap {
+    
+    const filterSensitiveLog: (obj: DetailsMap) => any;
+}
+
+export interface PrincipalResourcePermissions {
+    
+    Principal?: DataLakePrincipal;
+    
+    Resource?: Resource;
+    
+    Permissions?: (Permission | string)[];
+    
+    PermissionsWithGrantOption?: (Permission | string)[];
+    
+    AdditionalDetails?: DetailsMap;
+}
+export declare namespace PrincipalResourcePermissions {
+    
+    const filterSensitiveLog: (obj: PrincipalResourcePermissions) => any;
+}
+export interface GetEffectivePermissionsForPathResponse {
+    
+    Permissions?: PrincipalResourcePermissions[];
+    
+    NextToken?: string;
+}
+export declare namespace GetEffectivePermissionsForPathResponse {
+    
+    const filterSensitiveLog: (obj: GetEffectivePermissionsForPathResponse) => any;
+}
+export interface GetLFTagRequest {
+    
+    CatalogId?: string;
+    
+    TagKey: string | undefined;
+}
+export declare namespace GetLFTagRequest {
+    
+    const filterSensitiveLog: (obj: GetLFTagRequest) => any;
+}
+export interface GetLFTagResponse {
+    
+    CatalogId?: string;
+    
+    TagKey?: string;
+    
+    TagValues?: string[];
+}
+export declare namespace GetLFTagResponse {
+    
+    const filterSensitiveLog: (obj: GetLFTagResponse) => any;
+}
+export interface GetQueryStateRequest {
+    
+    QueryId: string | undefined;
+}
+export declare namespace GetQueryStateRequest {
+    
+    const filterSensitiveLog: (obj: GetQueryStateRequest) => any;
+}
+export declare enum QueryStateString {
+    ERROR = "ERROR",
+    EXPIRED = "EXPIRED",
+    FINISHED = "FINISHED",
+    PENDING = "PENDING",
+    WORKUNITS_AVAILABLE = "WORKUNITS_AVAILABLE"
+}
+
+export interface GetQueryStateResponse {
+    
+    Error?: string;
+    
+    State: QueryStateString | string | undefined;
+}
+export declare namespace GetQueryStateResponse {
+    
+    const filterSensitiveLog: (obj: GetQueryStateResponse) => any;
+}
+
+export declare class ExpiredException extends __BaseException {
+    readonly name: "ExpiredException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ExpiredException, __BaseException>);
+}
+export interface GetQueryStatisticsRequest {
+    
+    QueryId: string | undefined;
+}
+export declare namespace GetQueryStatisticsRequest {
+    
+    const filterSensitiveLog: (obj: GetQueryStatisticsRequest) => any;
+}
+
+export interface ExecutionStatistics {
+    
+    AverageExecutionTimeMillis?: number;
+    
+    DataScannedBytes?: number;
+    
+    WorkUnitsExecutedCount?: number;
+}
+export declare namespace ExecutionStatistics {
+    
+    const filterSensitiveLog: (obj: ExecutionStatistics) => any;
+}
+
+export interface PlanningStatistics {
+    
+    EstimatedDataToScanBytes?: number;
+    
+    PlanningTimeMillis?: number;
+    
+    QueueTimeMillis?: number;
+    
+    WorkUnitsGeneratedCount?: number;
+}
+export declare namespace PlanningStatistics {
+    
+    const filterSensitiveLog: (obj: PlanningStatistics) => any;
+}
+export interface GetQueryStatisticsResponse {
+    
+    ExecutionStatistics?: ExecutionStatistics;
+    
+    PlanningStatistics?: PlanningStatistics;
+    
+    QuerySubmissionTime?: Date;
+}
+export declare namespace GetQueryStatisticsResponse {
+    
+    const filterSensitiveLog: (obj: GetQueryStatisticsResponse) => any;
+}
+
+export declare class StatisticsNotReadyYetException extends __BaseException {
+    readonly name: "StatisticsNotReadyYetException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<StatisticsNotReadyYetException, __BaseException>);
+}
+
+export declare class ThrottledException extends __BaseException {
+    readonly name: "ThrottledException";
+    readonly $fault: "client";
+    $retryable: {
+        throttling: boolean;
+    };
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ThrottledException, __BaseException>);
+}
+export interface GetResourceLFTagsRequest {
+    
+    CatalogId?: string;
+    
+    Resource: Resource | undefined;
+    
+    ShowAssignedLFTags?: boolean;
+}
+export declare namespace GetResourceLFTagsRequest {
+    
+    const filterSensitiveLog: (obj: GetResourceLFTagsRequest) => any;
+}
+
+export interface ColumnLFTag {
+    
+    Name?: string;
+    
+    LFTags?: LFTagPair[];
+}
+export declare namespace ColumnLFTag {
+    
+    const filterSensitiveLog: (obj: ColumnLFTag) => any;
+}
+export interface GetResourceLFTagsResponse {
+    
+    LFTagOnDatabase?: LFTagPair[];
+    
+    LFTagsOnTable?: LFTagPair[];
+    
+    LFTagsOnColumns?: ColumnLFTag[];
+}
+export declare namespace GetResourceLFTagsResponse {
+    
+    const filterSensitiveLog: (obj: GetResourceLFTagsResponse) => any;
+}
+
+export declare class GlueEncryptionException extends __BaseException {
+    readonly name: "GlueEncryptionException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<GlueEncryptionException, __BaseException>);
+}
+export interface GetTableObjectsRequest {
+    
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    TransactionId?: string;
+    
+    QueryAsOfTime?: Date;
+    
+    PartitionPredicate?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetTableObjectsRequest {
+    
+    const filterSensitiveLog: (obj: GetTableObjectsRequest) => any;
+}
+
+export interface TableObject {
+    
+    Uri?: string;
+    
+    ETag?: string;
+    
+    Size?: number;
+}
+export declare namespace TableObject {
+    
+    const filterSensitiveLog: (obj: TableObject) => any;
+}
+
+export interface PartitionObjects {
+    
+    PartitionValues?: string[];
+    
+    Objects?: TableObject[];
+}
+export declare namespace PartitionObjects {
+    
+    const filterSensitiveLog: (obj: PartitionObjects) => any;
+}
+export interface GetTableObjectsResponse {
+    
+    Objects?: PartitionObjects[];
+    
+    NextToken?: string;
+}
+export declare namespace GetTableObjectsResponse {
+    
+    const filterSensitiveLog: (obj: GetTableObjectsResponse) => any;
+}
+
+export interface PartitionValueList {
+    
+    Values: string[] | undefined;
+}
+export declare namespace PartitionValueList {
+    
+    const filterSensitiveLog: (obj: PartitionValueList) => any;
+}
+export declare enum PermissionType {
+    CELL_FILTER_PERMISSION = "CELL_FILTER_PERMISSION",
+    COLUMN_PERMISSION = "COLUMN_PERMISSION"
+}
+export interface GetTemporaryGluePartitionCredentialsRequest {
+    
+    TableArn: string | undefined;
+    
+    Partition: PartitionValueList | undefined;
+    
+    Permissions?: (Permission | string)[];
+    
+    DurationSeconds?: number;
+    
+    AuditContext?: AuditContext;
+    
+    SupportedPermissionTypes: (PermissionType | string)[] | undefined;
+}
+export declare namespace GetTemporaryGluePartitionCredentialsRequest {
+    
+    const filterSensitiveLog: (obj: GetTemporaryGluePartitionCredentialsRequest) => any;
+}
+export interface GetTemporaryGluePartitionCredentialsResponse {
+    
+    AccessKeyId?: string;
+    
+    SecretAccessKey?: string;
+    
+    SessionToken?: string;
+    
+    Expiration?: Date;
+}
+export declare namespace GetTemporaryGluePartitionCredentialsResponse {
+    
+    const filterSensitiveLog: (obj: GetTemporaryGluePartitionCredentialsResponse) => any;
+}
+
+export declare class PermissionTypeMismatchException extends __BaseException {
+    readonly name: "PermissionTypeMismatchException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PermissionTypeMismatchException, __BaseException>);
+}
+export interface GetTemporaryGlueTableCredentialsRequest {
+    
+    TableArn: string | undefined;
+    
+    Permissions?: (Permission | string)[];
+    
+    DurationSeconds?: number;
+    
+    AuditContext?: AuditContext;
+    
+    SupportedPermissionTypes: (PermissionType | string)[] | undefined;
+}
+export declare namespace GetTemporaryGlueTableCredentialsRequest {
+    
+    const filterSensitiveLog: (obj: GetTemporaryGlueTableCredentialsRequest) => any;
+}
+export interface GetTemporaryGlueTableCredentialsResponse {
+    
+    AccessKeyId?: string;
+    
+    SecretAccessKey?: string;
+    
+    SessionToken?: string;
+    
+    Expiration?: Date;
+}
+export declare namespace GetTemporaryGlueTableCredentialsResponse {
+    
+    const filterSensitiveLog: (obj: GetTemporaryGlueTableCredentialsResponse) => any;
+}
+export interface GetWorkUnitResultsRequest {
+    
+    QueryId: string | undefined;
+    
+    WorkUnitId: number | undefined;
+    
+    WorkUnitToken: string | undefined;
+}
+export declare namespace GetWorkUnitResultsRequest {
+    
+    const filterSensitiveLog: (obj: GetWorkUnitResultsRequest) => any;
+}
+
+export interface GetWorkUnitResultsResponse {
+    
+    ResultStream?: Readable | ReadableStream | Blob;
+}
+export declare namespace GetWorkUnitResultsResponse {
+    
+    const filterSensitiveLog: (obj: GetWorkUnitResultsResponse) => any;
+}
+export interface GetWorkUnitsRequest {
+    
+    NextToken?: string;
+    
+    PageSize?: number;
+    
+    QueryId: string | undefined;
+}
+export declare namespace GetWorkUnitsRequest {
+    
+    const filterSensitiveLog: (obj: GetWorkUnitsRequest) => any;
+}
+
+export interface WorkUnitRange {
+    
+    WorkUnitIdMax: number | undefined;
+    
+    WorkUnitIdMin: number | undefined;
+    
+    WorkUnitToken: string | undefined;
+}
+export declare namespace WorkUnitRange {
+    
+    const filterSensitiveLog: (obj: WorkUnitRange) => any;
+}
+
+export interface GetWorkUnitsResponse {
+    
+    NextToken?: string;
+    
+    QueryId: string | undefined;
+    
+    WorkUnitRanges: WorkUnitRange[] | undefined;
+}
+export declare namespace GetWorkUnitsResponse {
+    
+    const filterSensitiveLog: (obj: GetWorkUnitsResponse) => any;
+}
+
+export declare class WorkUnitsNotReadyYetException extends __BaseException {
+    readonly name: "WorkUnitsNotReadyYetException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<WorkUnitsNotReadyYetException, __BaseException>);
+}
+export interface GrantPermissionsRequest {
+    
+    CatalogId?: string;
+    
+    Principal: DataLakePrincipal | undefined;
+    
+    Resource: Resource | undefined;
+    
+    Permissions: (Permission | string)[] | undefined;
+    
+    PermissionsWithGrantOption?: (Permission | string)[];
+}
+export declare namespace GrantPermissionsRequest {
+    
+    const filterSensitiveLog: (obj: GrantPermissionsRequest) => any;
+}
+export interface GrantPermissionsResponse {
+}
+export declare namespace GrantPermissionsResponse {
+    
+    const filterSensitiveLog: (obj: GrantPermissionsResponse) => any;
+}
+export interface ListDataCellsFilterRequest {
+    
+    Table?: TableResource;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDataCellsFilterRequest {
+    
+    const filterSensitiveLog: (obj: ListDataCellsFilterRequest) => any;
+}
+export interface ListDataCellsFilterResponse {
+    
+    DataCellsFilters?: DataCellsFilter[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDataCellsFilterResponse {
+    
+    const filterSensitiveLog: (obj: ListDataCellsFilterResponse) => any;
+}
+export declare enum ResourceShareType {
+    ALL = "ALL",
+    FOREIGN = "FOREIGN"
+}
+export interface ListLFTagsRequest {
+    
+    CatalogId?: string;
+    
+    ResourceShareType?: ResourceShareType | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListLFTagsRequest {
+    
+    const filterSensitiveLog: (obj: ListLFTagsRequest) => any;
+}
+export interface ListLFTagsResponse {
+    
+    LFTags?: LFTagPair[];
+    
+    NextToken?: string;
+}
+export declare namespace ListLFTagsResponse {
+    
+    const filterSensitiveLog: (obj: ListLFTagsResponse) => any;
+}
+export declare enum DataLakeResourceType {
+    CATALOG = "CATALOG",
+    DATABASE = "DATABASE",
+    DATA_LOCATION = "DATA_LOCATION",
+    LF_TAG = "LF_TAG",
+    LF_TAG_POLICY = "LF_TAG_POLICY",
+    LF_TAG_POLICY_DATABASE = "LF_TAG_POLICY_DATABASE",
+    LF_TAG_POLICY_TABLE = "LF_TAG_POLICY_TABLE",
+    TABLE = "TABLE"
+}
+export interface ListPermissionsRequest {
+    
+    CatalogId?: string;
+    
+    Principal?: DataLakePrincipal;
+    
+    ResourceType?: DataLakeResourceType | string;
+    
+    Resource?: Resource;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    IncludeRelated?: string;
+}
+export declare namespace ListPermissionsRequest {
+    
+    const filterSensitiveLog: (obj: ListPermissionsRequest) => any;
+}
+export interface ListPermissionsResponse {
+    
+    PrincipalResourcePermissions?: PrincipalResourcePermissions[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPermissionsResponse {
+    
+    const filterSensitiveLog: (obj: ListPermissionsResponse) => any;
+}
+export declare enum ComparisonOperator {
+    BEGINS_WITH = "BEGINS_WITH",
+    BETWEEN = "BETWEEN",
+    CONTAINS = "CONTAINS",
+    EQ = "EQ",
+    GE = "GE",
+    GT = "GT",
+    IN = "IN",
+    LE = "LE",
+    LT = "LT",
+    NE = "NE",
+    NOT_CONTAINS = "NOT_CONTAINS"
+}
+export declare enum FieldNameString {
+    LAST_MODIFIED = "LAST_MODIFIED",
+    RESOURCE_ARN = "RESOURCE_ARN",
+    ROLE_ARN = "ROLE_ARN"
+}
+
+export interface FilterCondition {
+    
+    Field?: FieldNameString | string;
+    
+    ComparisonOperator?: ComparisonOperator | string;
+    
+    StringValueList?: string[];
+}
+export declare namespace FilterCondition {
+    
+    const filterSensitiveLog: (obj: FilterCondition) => any;
+}
+export interface ListResourcesRequest {
+    
+    FilterConditionList?: FilterCondition[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListResourcesRequest {
+    
+    const filterSensitiveLog: (obj: ListResourcesRequest) => any;
+}
+export interface ListResourcesResponse {
+    
+    ResourceInfoList?: ResourceInfo[];
+    
+    NextToken?: string;
+}
+export declare namespace ListResourcesResponse {
+    
+    const filterSensitiveLog: (obj: ListResourcesResponse) => any;
+}
+export declare enum OptimizerType {
+    COMPACTION = "COMPACTION",
+    GARBAGE_COLLECTION = "GARBAGE_COLLECTION",
+    GENERIC = "ALL"
+}
+export interface ListTableStorageOptimizersRequest {
+    
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    StorageOptimizerType?: OptimizerType | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTableStorageOptimizersRequest {
+    
+    const filterSensitiveLog: (obj: ListTableStorageOptimizersRequest) => any;
+}
+
+export interface StorageOptimizer {
+    
+    StorageOptimizerType?: OptimizerType | string;
+    
+    Config?: {
+        [key: string]: string;
+    };
+    
+    ErrorMessage?: string;
+    
+    Warnings?: string;
+    
+    LastRunDetails?: string;
+}
+export declare namespace StorageOptimizer {
+    
+    const filterSensitiveLog: (obj: StorageOptimizer) => any;
+}
+export interface ListTableStorageOptimizersResponse {
+    
+    StorageOptimizerList?: StorageOptimizer[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTableStorageOptimizersResponse {
+    
+    const filterSensitiveLog: (obj: ListTableStorageOptimizersResponse) => any;
+}
+export declare enum TransactionStatusFilter {
+    ABORTED = "ABORTED",
+    ACTIVE = "ACTIVE",
+    ALL = "ALL",
+    COMMITTED = "COMMITTED",
+    COMPLETED = "COMPLETED"
+}
+export interface ListTransactionsRequest {
+    
+    CatalogId?: string;
+    
+    StatusFilter?: TransactionStatusFilter | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTransactionsRequest {
+    
+    const filterSensitiveLog: (obj: ListTransactionsRequest) => any;
+}
+export interface ListTransactionsResponse {
+    
+    Transactions?: TransactionDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTransactionsResponse {
+    
+    const filterSensitiveLog: (obj: ListTransactionsResponse) => any;
+}
+export interface PutDataLakeSettingsRequest {
+    
+    CatalogId?: string;
+    
+    DataLakeSettings: DataLakeSettings | undefined;
+}
+export declare namespace PutDataLakeSettingsRequest {
+    
+    const filterSensitiveLog: (obj: PutDataLakeSettingsRequest) => any;
+}
+export interface PutDataLakeSettingsResponse {
+}
+export declare namespace PutDataLakeSettingsResponse {
+    
+    const filterSensitiveLog: (obj: PutDataLakeSettingsResponse) => any;
+}
+export interface RegisterResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    UseServiceLinkedRole?: boolean;
+    
+    RoleArn?: string;
+}
+export declare namespace RegisterResourceRequest {
+    
+    const filterSensitiveLog: (obj: RegisterResourceRequest) => any;
+}
+export interface RegisterResourceResponse {
+}
+export declare namespace RegisterResourceResponse {
+    
+    const filterSensitiveLog: (obj: RegisterResourceResponse) => any;
+}
+export interface RemoveLFTagsFromResourceRequest {
+    
+    CatalogId?: string;
+    
+    Resource: Resource | undefined;
+    
+    LFTags: LFTagPair[] | undefined;
+}
+export declare namespace RemoveLFTagsFromResourceRequest {
+    
+    const filterSensitiveLog: (obj: RemoveLFTagsFromResourceRequest) => any;
+}
+export interface RemoveLFTagsFromResourceResponse {
+    
+    Failures?: LFTagError[];
+}
+export declare namespace RemoveLFTagsFromResourceResponse {
+    
+    const filterSensitiveLog: (obj: RemoveLFTagsFromResourceResponse) => any;
+}
+export interface RevokePermissionsRequest {
+    
+    CatalogId?: string;
+    
+    Principal: DataLakePrincipal | undefined;
+    
+    Resource: Resource | undefined;
+    
+    Permissions: (Permission | string)[] | undefined;
+    
+    PermissionsWithGrantOption?: (Permission | string)[];
+}
+export declare namespace RevokePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: RevokePermissionsRequest) => any;
+}
+export interface RevokePermissionsResponse {
+}
+export declare namespace RevokePermissionsResponse {
+    
+    const filterSensitiveLog: (obj: RevokePermissionsResponse) => any;
+}
+export interface SearchDatabasesByLFTagsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    CatalogId?: string;
+    
+    Expression: LFTag[] | undefined;
+}
+export declare namespace SearchDatabasesByLFTagsRequest {
+    
+    const filterSensitiveLog: (obj: SearchDatabasesByLFTagsRequest) => any;
+}
+
+export interface TaggedDatabase {
+    
+    Database?: DatabaseResource;
+    
+    LFTags?: LFTagPair[];
+}
+export declare namespace TaggedDatabase {
+    
+    const filterSensitiveLog: (obj: TaggedDatabase) => any;
+}
+export interface SearchDatabasesByLFTagsResponse {
+    
+    NextToken?: string;
+    
+    DatabaseList?: TaggedDatabase[];
+}
+export declare namespace SearchDatabasesByLFTagsResponse {
+    
+    const filterSensitiveLog: (obj: SearchDatabasesByLFTagsResponse) => any;
+}
+export interface SearchTablesByLFTagsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    CatalogId?: string;
+    
+    Expression: LFTag[] | undefined;
+}
+export declare namespace SearchTablesByLFTagsRequest {
+    
+    const filterSensitiveLog: (obj: SearchTablesByLFTagsRequest) => any;
+}
+
+export interface TaggedTable {
+    
+    Table?: TableResource;
+    
+    LFTagOnDatabase?: LFTagPair[];
+    
+    LFTagsOnTable?: LFTagPair[];
+    
+    LFTagsOnColumns?: ColumnLFTag[];
+}
+export declare namespace TaggedTable {
+    
+    const filterSensitiveLog: (obj: TaggedTable) => any;
+}
+export interface SearchTablesByLFTagsResponse {
+    
+    NextToken?: string;
+    
+    TableList?: TaggedTable[];
+}
+export declare namespace SearchTablesByLFTagsResponse {
+    
+    const filterSensitiveLog: (obj: SearchTablesByLFTagsResponse) => any;
+}
+
+export interface QueryPlanningContext {
+    
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    QueryAsOfTime?: Date;
+    
+    QueryParameters?: {
+        [key: string]: string;
+    };
+    
+    TransactionId?: string;
+}
+export declare namespace QueryPlanningContext {
+    
+    const filterSensitiveLog: (obj: QueryPlanningContext) => any;
+}
+export interface StartQueryPlanningRequest {
+    
+    QueryPlanningContext: QueryPlanningContext | undefined;
+    
+    QueryString: string | undefined;
+}
+export declare namespace StartQueryPlanningRequest {
+    
+    const filterSensitiveLog: (obj: StartQueryPlanningRequest) => any;
+}
+
+export interface StartQueryPlanningResponse {
+    
+    QueryId: string | undefined;
+}
+export declare namespace StartQueryPlanningResponse {
+    
+    const filterSensitiveLog: (obj: StartQueryPlanningResponse) => any;
+}
+export declare enum TransactionType {
+    READ_AND_WRITE = "READ_AND_WRITE",
+    READ_ONLY = "READ_ONLY"
+}
+export interface StartTransactionRequest {
+    
+    TransactionType?: TransactionType | string;
+}
+export declare namespace StartTransactionRequest {
+    
+    const filterSensitiveLog: (obj: StartTransactionRequest) => any;
+}
+export interface StartTransactionResponse {
+    
+    TransactionId?: string;
+}
+export declare namespace StartTransactionResponse {
+    
+    const filterSensitiveLog: (obj: StartTransactionResponse) => any;
+}
+export interface UpdateLFTagRequest {
+    
+    CatalogId?: string;
+    
+    TagKey: string | undefined;
+    
+    TagValuesToDelete?: string[];
+    
+    TagValuesToAdd?: string[];
+}
+export declare namespace UpdateLFTagRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLFTagRequest) => any;
+}
+export interface UpdateLFTagResponse {
+}
+export declare namespace UpdateLFTagResponse {
+    
+    const filterSensitiveLog: (obj: UpdateLFTagResponse) => any;
+}
+export interface UpdateResourceRequest {
+    
+    RoleArn: string | undefined;
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace UpdateResourceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateResourceRequest) => any;
+}
+export interface UpdateResourceResponse {
+}
+export declare namespace UpdateResourceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateResourceResponse) => any;
+}
+
+export interface DeleteObjectInput {
+    
+    Uri: string | undefined;
+    
+    ETag?: string;
+    
+    PartitionValues?: string[];
+}
+export declare namespace DeleteObjectInput {
+    
+    const filterSensitiveLog: (obj: DeleteObjectInput) => any;
+}
+
+export interface WriteOperation {
+    
+    AddObject?: AddObjectInput;
+    
+    DeleteObject?: DeleteObjectInput;
+}
+export declare namespace WriteOperation {
+    
+    const filterSensitiveLog: (obj: WriteOperation) => any;
+}
+export interface UpdateTableObjectsRequest {
+    
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    TransactionId?: string;
+    
+    WriteOperations: WriteOperation[] | undefined;
+}
+export declare namespace UpdateTableObjectsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTableObjectsRequest) => any;
+}
+export interface UpdateTableObjectsResponse {
+}
+export declare namespace UpdateTableObjectsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTableObjectsResponse) => any;
+}
+export interface UpdateTableStorageOptimizerRequest {
+    
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
+    
+    StorageOptimizerConfig: {
+        [key: string]: {
+            [key: string]: string;
+        };
+    } | undefined;
+}
+export declare namespace UpdateTableStorageOptimizerRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTableStorageOptimizerRequest) => any;
+}
+export interface UpdateTableStorageOptimizerResponse {
+    
+    Result?: string;
+}
+export declare namespace UpdateTableStorageOptimizerResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTableStorageOptimizerResponse) => any;
+}