@aws-sdk/client-lakeformation 3.42.0 → 3.46.0

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

@@ -1,4 +1,6 @@
+
 import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { Readable } from "stream";
 
 export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
     name: "AccessDeniedException";
@@ -42,6 +44,21 @@ 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;
@@ -154,6 +171,8 @@ export interface Resource {
     
     DataLocation?: DataLocationResource;
     
+    DataCellsFilter?: DataCellsFilterResource;
+    
     LFTag?: LFTagKeyResource;
     
     LFTagPolicy?: LFTagPolicyResource;
@@ -260,6 +279,28 @@ export declare namespace OperationTimeoutException {
     const filterSensitiveLog: (obj: OperationTimeoutException) => any;
 }
 
+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 interface AlreadyExistsException extends __SmithyException, $MetadataBearer {
     name: "AlreadyExistsException";
     $fault: "client";
@@ -270,6 +311,15 @@ export declare namespace AlreadyExistsException {
     
     const filterSensitiveLog: (obj: AlreadyExistsException) => any;
 }
+
+export interface AuditContext {
+    
+    AdditionalAuditContext?: string;
+}
+export declare namespace AuditContext {
+    
+    const filterSensitiveLog: (obj: AuditContext) => any;
+}
 export declare enum Permission {
     ALL = "ALL",
     ALTER = "ALTER",
@@ -360,6 +410,132 @@ 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 interface TransactionCommitInProgressException extends __SmithyException, $MetadataBearer {
+    name: "TransactionCommitInProgressException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace TransactionCommitInProgressException {
+    
+    const filterSensitiveLog: (obj: TransactionCommitInProgressException) => any;
+}
+
+export interface TransactionCommittedException extends __SmithyException, $MetadataBearer {
+    name: "TransactionCommittedException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace TransactionCommittedException {
+    
+    const filterSensitiveLog: (obj: TransactionCommittedException) => any;
+}
+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 interface TransactionCanceledException extends __SmithyException, $MetadataBearer {
+    name: "TransactionCanceledException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace TransactionCanceledException {
+    
+    const filterSensitiveLog: (obj: TransactionCanceledException) => any;
+}
+
+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 interface ResourceNumberLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNumberLimitExceededException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceNumberLimitExceededException {
+    
+    const filterSensitiveLog: (obj: ResourceNumberLimitExceededException) => any;
+}
 export interface CreateLFTagRequest {
     
     CatalogId?: string;
@@ -378,16 +554,25 @@ export declare namespace CreateLFTagResponse {
     
     const filterSensitiveLog: (obj: CreateLFTagResponse) => any;
 }
-
-export interface ResourceNumberLimitExceededException extends __SmithyException, $MetadataBearer {
-    name: "ResourceNumberLimitExceededException";
-    $fault: "client";
+export interface DeleteDataCellsFilterRequest {
     
-    Message?: string;
+    TableCatalogId?: string;
+    
+    DatabaseName?: string;
+    
+    TableName?: string;
+    
+    Name?: string;
 }
-export declare namespace ResourceNumberLimitExceededException {
+export declare namespace DeleteDataCellsFilterRequest {
     
-    const filterSensitiveLog: (obj: ResourceNumberLimitExceededException) => any;
+    const filterSensitiveLog: (obj: DeleteDataCellsFilterRequest) => any;
+}
+export interface DeleteDataCellsFilterResponse {
+}
+export declare namespace DeleteDataCellsFilterResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDataCellsFilterResponse) => any;
 }
 export interface DeleteLFTagRequest {
     
@@ -405,6 +590,50 @@ 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 interface ResourceNotReadyException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotReadyException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceNotReadyException {
+    
+    const filterSensitiveLog: (obj: ResourceNotReadyException) => any;
+}
 export interface DeregisterResourceRequest {
     
     ResourceArn: string | undefined;
@@ -448,6 +677,51 @@ 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;
@@ -477,6 +751,12 @@ export interface DataLakeSettings {
     CreateTableDefaultPermissions?: PrincipalPermissions[];
     
     TrustedResourceOwners?: string[];
+    
+    AllowExternalDataFiltering?: boolean;
+    
+    ExternalDataFilteringAllowList?: DataLakePrincipal[];
+    
+    AuthorizedSessionTagValueList?: string[];
 }
 export declare namespace DataLakeSettings {
     
@@ -562,6 +842,116 @@ 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 interface ExpiredException extends __SmithyException, $MetadataBearer {
+    name: "ExpiredException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ExpiredException {
+    
+    const filterSensitiveLog: (obj: ExpiredException) => any;
+}
+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 interface StatisticsNotReadyYetException extends __SmithyException, $MetadataBearer {
+    name: "StatisticsNotReadyYetException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace StatisticsNotReadyYetException {
+    
+    const filterSensitiveLog: (obj: StatisticsNotReadyYetException) => any;
+}
+
+export interface ThrottledException extends __SmithyException, $MetadataBearer {
+    name: "ThrottledException";
+    $fault: "client";
+    $retryable: {
+        throttling: true;
+    };
+    
+    Message?: string;
+}
+export declare namespace ThrottledException {
+    
+    const filterSensitiveLog: (obj: ThrottledException) => any;
+}
 export interface GetResourceLFTagsRequest {
     
     CatalogId?: string;
@@ -608,6 +998,218 @@ export declare namespace GlueEncryptionException {
     
     const filterSensitiveLog: (obj: GlueEncryptionException) => any;
 }
+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 interface PermissionTypeMismatchException extends __SmithyException, $MetadataBearer {
+    name: "PermissionTypeMismatchException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace PermissionTypeMismatchException {
+    
+    const filterSensitiveLog: (obj: PermissionTypeMismatchException) => any;
+}
+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 interface WorkUnitsNotReadyYetException extends __SmithyException, $MetadataBearer {
+    name: "WorkUnitsNotReadyYetException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace WorkUnitsNotReadyYetException {
+    
+    const filterSensitiveLog: (obj: WorkUnitsNotReadyYetException) => any;
+}
 export interface GrantPermissionsRequest {
     
     CatalogId?: string;
@@ -630,6 +1232,28 @@ 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"
@@ -681,6 +1305,8 @@ export interface ListPermissionsRequest {
     NextToken?: string;
     
     MaxResults?: number;
+    
+    IncludeRelated?: string;
 }
 export declare namespace ListPermissionsRequest {
     
@@ -749,6 +1375,89 @@ 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;
@@ -899,6 +1608,64 @@ 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;
@@ -935,3 +1702,75 @@ 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 | undefined;
+    
+    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;
+}