@xylex-group/athena 2.8.0 → 2.8.2

package/dist/{model-form-DXPlOnlI.d.ts → model-form-_ugfOXao.d.cts}

@@ -1,4 +1,4 @@
-import { j as AthenaModelTarget, H as RowOf, r as InsertOf, U as UpdateOf, i as AthenaJsonValue, a as AthenaGatewayCallOptions, g as AthenaJsonObject, k as AthenaRpcCallOptions, Z as AthenaGatewayEndpointPath, _ as AthenaGatewayMethod, $ as AthenaConditionValue, a0 as AthenaConditionArrayValue, R as RegistryDef, D as DatabaseDef, J as SchemaDef, N as AnyModelDef, C as ModelDef, G as ModelRelationMetadata, a1 as AthenaGatewayCondition, a2 as AthenaSortBy, V as AthenaFetchPayload, X as AthenaInsertPayload, Y as AthenaUpdatePayload, Q as AthenaDeletePayload, l as AthenaRpcFilter, o as AthenaRpcPayload, p as BackendConfig, q as BackendType, e as AthenaGatewayErrorDetails, A as AthenaConditionCastType, a3 as AthenaConditionOperator, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, d as AthenaGatewayErrorCode, W as AthenaGatewayResponse } from './types-vikz9YIO.js';
+import { j as AthenaModelTarget, H as RowOf, r as InsertOf, U as UpdateOf, i as AthenaJsonValue, a as AthenaGatewayCallOptions, g as AthenaJsonObject, k as AthenaRpcCallOptions, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, V as AthenaFetchPayload, W as AthenaGatewayResponse, X as AthenaInsertPayload, Y as AthenaUpdatePayload, Q as AthenaDeletePayload, o as AthenaRpcPayload, Z as AthenaQueryPayload, _ as AthenaGatewayEndpointPath, $ as AthenaGatewayMethod, a0 as AthenaConditionValue, a1 as AthenaConditionArrayValue, R as RegistryDef, D as DatabaseDef, J as SchemaDef, N as AnyModelDef, C as ModelDef, G as ModelRelationMetadata, a2 as AthenaGatewayCondition, a3 as AthenaSortBy, l as AthenaRpcFilter, p as BackendConfig, q as BackendType, e as AthenaGatewayErrorDetails, A as AthenaConditionCastType, a4 as AthenaConditionOperator, d as AthenaGatewayErrorCode } from './types-g8G6J0xE.cjs';
 
 type AthenaAuthMethod = 'GET' | 'POST';
 type AthenaAuthCredentials = 'omit' | 'same-origin' | 'include';
@@ -1510,6 +1510,26 @@ interface AthenaDbModule<TStrict extends boolean = false> {
     query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
 }
 
+interface AthenaFindManyAstPayload$1 {
+    table_name: string;
+    select: Record<string, unknown>;
+    where?: Record<string, unknown>;
+    orderBy?: Record<string, unknown>;
+    limit?: number;
+}
+declare function verifyAthenaGatewayUrl(baseUrl: string, options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+interface AthenaGatewayClient {
+    baseUrl: string;
+    buildHeaders(options?: AthenaGatewayCallOptions): Record<string, string>;
+    verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+    fetchGateway<T>(payload: AthenaFetchPayload | AthenaFindManyAstPayload$1, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+    insertGateway<T>(payload: AthenaInsertPayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+    updateGateway<T>(payload: AthenaUpdatePayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+    deleteGateway<T>(payload: AthenaDeletePayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+    rpcGateway<T>(payload: AthenaRpcPayload, options?: AthenaRpcCallOptions): Promise<AthenaGatewayResponse<T>>;
+    queryGateway<T>(payload: AthenaQueryPayload, options?: AthenaGatewayCallOptions): Promise<AthenaGatewayResponse<T>>;
+}
+
 type AthenaStorageTemplateValue = string | number | boolean | null | undefined;
 type AthenaStorageTemplateVars = Record<string, AthenaStorageTemplateValue>;
 type AthenaStorageEnv = Record<string, string | undefined>;
@@ -1556,7 +1576,7 @@ interface AthenaStorageUploadProgress {
     aggregatePercent: number;
 }
 type AthenaStorageUploadProgressHandler = (progress: AthenaStorageUploadProgress) => void;
-interface AthenaStorageFileUploadInput extends AthenaStorageUploadConstraints {
+interface AthenaStorageFileUploadInput extends AthenaStorageUploadConstraints, StorageServerSideEncryptionOptions {
     s3_id: string;
     bucket?: string;
     files: AthenaStorageUploadSource | ArrayLike<AthenaStorageUploadSource> | readonly AthenaStorageUploadSource[];
@@ -1730,6 +1750,21 @@ declare const storageSdkManifest: {
         readonly requestType: "SetStorageFileVisibilityRequest";
         readonly responseEnvelope: "athena";
         readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "postStorageFileVisibility";
+        readonly method: "POST";
+        readonly path: "/storage/files/{file_id}/visibility";
+        readonly pathParams: readonly ["file_id"];
+        readonly requestType: "SetStorageFileVisibilityRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "setManyStorageFileVisibility";
+        readonly method: "POST";
+        readonly path: "/storage/files/visibility-many";
+        readonly requestType: "SetManyStorageFileVisibilityRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationManyResponse";
     }, {
         readonly name: "deleteStorageFolder";
         readonly method: "POST";
@@ -1744,6 +1779,425 @@ declare const storageSdkManifest: {
         readonly requestType: "MoveStorageFolderRequest";
         readonly responseEnvelope: "athena";
         readonly responseType: "StorageFolderMutationResponse";
+    }, {
+        readonly name: "searchStorageFiles";
+        readonly method: "POST";
+        readonly path: "/storage/files/search";
+        readonly requestType: "SearchStorageFilesRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageListFilesResponse";
+    }, {
+        readonly name: "confirmStorageUpload";
+        readonly method: "POST";
+        readonly path: "/storage/files/{file_id}/confirm-upload";
+        readonly pathParams: readonly ["file_id"];
+        readonly requestType: "ConfirmStorageUploadRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "uploadStorageFileBinary";
+        readonly method: "PUT";
+        readonly path: "/storage/files/{file_id}/upload";
+        readonly pathParams: readonly ["file_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+        readonly binary: true;
+    }, {
+        readonly name: "copyStorageFile";
+        readonly method: "POST";
+        readonly path: "/storage/files/{file_id}/copy";
+        readonly pathParams: readonly ["file_id"];
+        readonly requestType: "CopyStorageFileRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "deleteManyStorageFiles";
+        readonly method: "POST";
+        readonly path: "/storage/files/delete-many";
+        readonly requestType: "DeleteManyStorageFilesRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationManyResponse";
+    }, {
+        readonly name: "updateManyStorageFiles";
+        readonly method: "POST";
+        readonly path: "/storage/files/update-many";
+        readonly requestType: "UpdateManyStorageFilesRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationManyResponse";
+    }, {
+        readonly name: "restoreStorageFile";
+        readonly method: "POST";
+        readonly path: "/storage/files/{file_id}/restore";
+        readonly pathParams: readonly ["file_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "purgeStorageFile";
+        readonly method: "DELETE";
+        readonly path: "/storage/files/{file_id}/purge";
+        readonly pathParams: readonly ["file_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "getStorageFilePublicUrl";
+        readonly method: "GET";
+        readonly path: "/storage/files/{file_id}/public-url";
+        readonly pathParams: readonly ["file_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "getStorageFileProxyUrl";
+        readonly method: "GET";
+        readonly path: "/storage/files/{file_id}/proxy-url";
+        readonly pathParams: readonly ["file_id"];
+        readonly queryParams: readonly ["purpose"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "listStorageFileVersions";
+        readonly method: "GET";
+        readonly path: "/storage/files/{file_id}/versions";
+        readonly pathParams: readonly ["file_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "restoreStorageFileVersion";
+        readonly method: "POST";
+        readonly path: "/storage/files/{file_id}/versions/{version_id}/restore";
+        readonly pathParams: readonly ["file_id", "version_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageFileVersion";
+        readonly method: "DELETE";
+        readonly path: "/storage/files/{file_id}/versions/{version_id}";
+        readonly pathParams: readonly ["file_id", "version_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "getStorageFileRetention";
+        readonly method: "GET";
+        readonly path: "/storage/files/{file_id}/retention";
+        readonly pathParams: readonly ["file_id"];
+        readonly queryParams: readonly ["version_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "setStorageFileRetention";
+        readonly method: "POST";
+        readonly path: "/storage/files/{file_id}/retention";
+        readonly pathParams: readonly ["file_id"];
+        readonly requestType: "StorageFileRetentionRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "listStorageFolders";
+        readonly method: "POST";
+        readonly path: "/storage/folders/list";
+        readonly requestType: "ListStorageFoldersRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "treeStorageFolders";
+        readonly method: "POST";
+        readonly path: "/storage/folders/tree";
+        readonly requestType: "TreeStorageFoldersRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "listStoragePermissions";
+        readonly method: "POST";
+        readonly path: "/storage/permissions/list";
+        readonly requestType: "StoragePermissionListRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StoragePermissionListResponse";
+    }, {
+        readonly name: "grantStoragePermission";
+        readonly method: "POST";
+        readonly path: "/storage/permissions/grant";
+        readonly requestType: "StoragePermissionGrantRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "revokeStoragePermission";
+        readonly method: "POST";
+        readonly path: "/storage/permissions/revoke";
+        readonly requestType: "StoragePermissionRevokeRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "checkStoragePermission";
+        readonly method: "POST";
+        readonly path: "/storage/permissions/check";
+        readonly requestType: "StoragePermissionCheckRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StoragePermissionCheckResponse";
+    }, {
+        readonly name: "listStorageObjects";
+        readonly method: "POST";
+        readonly path: "/storage/objects";
+        readonly requestType: "StorageListObjectsRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "headStorageObject";
+        readonly method: "POST";
+        readonly path: "/storage/objects/head";
+        readonly requestType: "StorageObjectRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "existsStorageObject";
+        readonly method: "POST";
+        readonly path: "/storage/objects/exists";
+        readonly requestType: "StorageObjectRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "validateStorageObject";
+        readonly method: "POST";
+        readonly path: "/storage/objects/validate";
+        readonly requestType: "StorageObjectValidateRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "updateStorageObject";
+        readonly method: "POST";
+        readonly path: "/storage/objects/update";
+        readonly requestType: "StorageUpdateObjectRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "copyStorageObject";
+        readonly method: "POST";
+        readonly path: "/storage/objects/copy";
+        readonly requestType: "StorageObjectCopyRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "getStorageObjectUrl";
+        readonly method: "POST";
+        readonly path: "/storage/objects/url";
+        readonly requestType: "StorageObjectRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "getStorageObjectPublicUrl";
+        readonly method: "POST";
+        readonly path: "/storage/objects/public-url";
+        readonly requestType: "StorageObjectPublicUrlRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageObject";
+        readonly method: "POST";
+        readonly path: "/storage/objects/delete";
+        readonly requestType: "StorageObjectRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "createStorageObjectUploadUrl";
+        readonly method: "POST";
+        readonly path: "/storage/objects/upload-url";
+        readonly requestType: "StoragePresignUploadRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "createStorageObjectPostPolicy";
+        readonly method: "POST";
+        readonly path: "/storage/objects/post-policy";
+        readonly requestType: "StorageSignedPostPolicyRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "listStorageObjectVersions";
+        readonly method: "POST";
+        readonly path: "/storage/objects/versions";
+        readonly requestType: "StorageObjectVersionListRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "restoreStorageObjectVersion";
+        readonly method: "POST";
+        readonly path: "/storage/objects/versions/restore";
+        readonly requestType: "StorageObjectVersionMutationRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageObjectVersion";
+        readonly method: "POST";
+        readonly path: "/storage/objects/versions/delete";
+        readonly requestType: "StorageObjectVersionMutationRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "createStorageObjectFolder";
+        readonly method: "POST";
+        readonly path: "/storage/objects/folder";
+        readonly requestType: "StorageObjectFolderCreateRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageObjectFolder";
+        readonly method: "POST";
+        readonly path: "/storage/objects/folder/delete";
+        readonly requestType: "StorageObjectFolderDeleteRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "renameStorageObjectFolder";
+        readonly method: "POST";
+        readonly path: "/storage/objects/folder/rename";
+        readonly requestType: "StorageObjectFolderRenameRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "listStorageBuckets";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/list";
+        readonly requestType: "Omit<StorageObjectBaseRequest, 'bucket'>";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "createStorageBucket";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/create";
+        readonly requestType: "StorageObjectBaseRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageBucket";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/delete";
+        readonly requestType: "StorageObjectBaseRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "getStorageBucketLifecycle";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/lifecycle";
+        readonly requestType: "StorageBucketLifecycleRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "setStorageBucketLifecycle";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/lifecycle/set";
+        readonly requestType: "StorageSetBucketLifecycleRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageBucketLifecycle";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/lifecycle/delete";
+        readonly requestType: "StorageBucketLifecycleRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "getStorageBucketPolicy";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/policy";
+        readonly requestType: "StorageBucketPolicyRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "setStorageBucketPolicy";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/policy/set";
+        readonly requestType: "StorageSetBucketPolicyRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageBucketPolicy";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/policy/delete";
+        readonly requestType: "StorageBucketPolicyRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "getStorageBucketPublicAccess";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/public-access";
+        readonly requestType: "StoragePublicAccessBlockRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "setStorageBucketPublicAccess";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/public-access/set";
+        readonly requestType: "StorageSetPublicAccessBlockRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageBucketPublicAccess";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/public-access/delete";
+        readonly requestType: "StoragePublicAccessBlockRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "getStorageBucketCors";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/cors";
+        readonly requestType: "StorageBucketCorsRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "setStorageBucketCors";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/cors/set";
+        readonly requestType: "StorageSetBucketCorsRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "deleteStorageBucketCors";
+        readonly method: "POST";
+        readonly path: "/storage/buckets/cors/delete";
+        readonly requestType: "StorageBucketCorsRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "createStorageMultipartUpload";
+        readonly method: "POST";
+        readonly path: "/storage/multipart/create";
+        readonly requestType: "StorageMultipartCreateRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "signStorageMultipartPart";
+        readonly method: "POST";
+        readonly path: "/storage/multipart/sign-part";
+        readonly requestType: "StorageMultipartSignPartRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "completeStorageMultipartUpload";
+        readonly method: "POST";
+        readonly path: "/storage/multipart/complete";
+        readonly requestType: "StorageMultipartCompleteRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "abortStorageMultipartUpload";
+        readonly method: "POST";
+        readonly path: "/storage/multipart/abort";
+        readonly requestType: "StorageMultipartAbortRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "listStorageMultipartParts";
+        readonly method: "POST";
+        readonly path: "/storage/multipart/list-parts";
+        readonly requestType: "StorageMultipartListPartsRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "Record<string, unknown>";
+    }, {
+        readonly name: "listStorageAuditEvents";
+        readonly method: "POST";
+        readonly path: "/storage/audit/list";
+        readonly requestType: "StorageAuditQueryRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageAuditListResponse";
     }];
 };
 interface S3CatalogItem {
@@ -1807,12 +2261,20 @@ interface PresignedFileUrlResponse {
     storage_key: string;
     purpose: string;
     url: string;
+    headers?: Record<string, string>;
     expires_at: string;
     expires_at_epoch_seconds: number;
     expires_in: number;
     cache_hit: boolean;
     cache_layer: string;
 }
+interface StorageServerSideEncryptionOptions {
+    server_side_encryption?: 'AES256' | 'aws:kms' | 'aws:kms:dsse' | (string & {});
+    sse?: 'AES256' | 'aws:kms' | 'aws:kms:dsse' | (string & {});
+    ssekms_key_id?: string;
+    kms_key_id?: string;
+    bucket_key_enabled?: boolean;
+}
 interface CreateStorageCatalogRequest {
     name: string;
     endpoint: string;
@@ -1842,7 +2304,7 @@ interface UpdateStorageCatalogRequest {
     is_active?: boolean;
     metadata?: Record<string, unknown>;
 }
-interface CreateStorageUploadUrlRequest {
+interface CreateStorageUploadUrlRequest extends StorageServerSideEncryptionOptions {
     s3_id: string;
     bucket?: string;
     storage_key: string;
@@ -1869,15 +2331,42 @@ interface StorageBatchUploadUrlResponse {
 }
 interface ListStorageFilesRequest {
     s3_id: string;
-    prefix: string;
+    prefix?: string;
+    limit?: number;
+    offset?: number;
+    metadata?: Record<string, unknown>;
+    name?: string;
+    resource_id?: string;
+    mime_type?: string;
+    content_type?: string;
+    status?: string;
+    visibility?: 'private' | 'organization' | 'public' | (string & {});
+    bucket?: string;
+    key_prefix?: string;
 }
 interface StorageListFilesResponse {
     files: ManagedFileRecord[];
     count: number;
+    total?: number;
+    limit?: number;
+    offset?: number;
+    next_offset?: number | null;
+    has_more?: boolean;
 }
 interface UpdateStorageFileRequest {
-    storage_key: string;
+    storage_key?: string;
     bucket?: string;
+    name?: string;
+    file_name?: string;
+    original_name?: string;
+    resource_id?: string;
+    mime_type?: string;
+    content_type?: string;
+    size_bytes?: number;
+    checksum_sha256?: string;
+    visibility?: 'private' | 'organization' | 'public' | (string & {});
+    status?: string;
+    metadata?: Record<string, unknown>;
 }
 interface SetStorageFileVisibilityRequest {
     public?: boolean;
@@ -1951,21 +2440,44 @@ interface ConfirmStorageUploadRequest {
 interface SearchStorageFilesRequest {
     query?: string;
     limit?: number;
+    offset?: number;
+    s3_id?: string;
+    prefix?: string;
+    metadata?: Record<string, unknown>;
+    name?: string;
+    resource_id?: string;
+    mime_type?: string;
+    content_type?: string;
+    status?: string;
+    visibility?: 'private' | 'organization' | 'public' | (string & {});
+    bucket?: string;
+    key_prefix?: string;
 }
 interface DeleteManyStorageFilesRequest {
     file_ids: string[];
 }
 interface UpdateManyStorageFilesRequest {
     file_ids: string[];
-    storage_key: string;
+    storage_key?: string;
     bucket?: string;
+    name?: string;
+    file_name?: string;
+    original_name?: string;
+    resource_id?: string;
+    mime_type?: string;
+    content_type?: string;
+    size_bytes?: number;
+    checksum_sha256?: string;
+    visibility?: 'private' | 'organization' | 'public' | (string & {});
+    status?: string;
+    metadata?: Record<string, unknown>;
 }
 interface SetManyStorageFileVisibilityRequest {
     file_ids: string[];
     public?: boolean;
     visibility?: 'private' | 'organization' | 'public';
 }
-interface CopyStorageFileRequest {
+interface CopyStorageFileRequest extends StorageServerSideEncryptionOptions {
     storage_key: string;
     bucket?: string;
     file_name?: string;
@@ -2001,7 +2513,7 @@ interface StoragePermissionCheckRequest {
     file_id: string;
     permission: 'read' | 'write' | 'delete' | 'share' | 'owner';
 }
-interface StorageMultipartCreateRequest {
+interface StorageMultipartCreateRequest extends StorageServerSideEncryptionOptions {
     file_id: string;
     content_type?: string;
 }
@@ -2050,7 +2562,11 @@ interface StorageObjectBaseRequest {
 interface StorageObjectRequest extends StorageObjectBaseRequest {
     key: string;
 }
-interface StorageObjectCopyRequest extends StorageObjectBaseRequest {
+interface StorageObjectValidateRequest extends StorageObjectRequest {
+    checksum_sha256?: string;
+    etag?: string;
+}
+interface StorageObjectCopyRequest extends StorageObjectBaseRequest, StorageServerSideEncryptionOptions {
     source_key: string;
     destination_key: string;
     destination_bucket?: string;
@@ -2074,7 +2590,26 @@ interface StorageUpdateObjectRequest extends StorageObjectRequest {
     content_language?: string;
     metadata?: Record<string, string>;
 }
-interface StoragePresignUploadRequest extends StorageObjectRequest {
+interface StorageObjectVersionListRequest extends StorageObjectBaseRequest {
+    key?: string;
+    max_keys?: number;
+    key_marker?: string;
+    version_id_marker?: string;
+    delimiter?: string;
+}
+interface StorageObjectVersionMutationRequest extends StorageObjectRequest {
+    version_id: string;
+}
+interface StorageSignedPostPolicyRequest extends StorageObjectRequest, StorageServerSideEncryptionOptions {
+    content_type?: string;
+    min_size?: number;
+    max_size?: number;
+    expires_in?: number;
+    public_base_url?: string;
+    force_path_style?: boolean;
+    success_action_status?: string;
+}
+interface StoragePresignUploadRequest extends StorageObjectRequest, StorageServerSideEncryptionOptions {
     content_type?: string;
 }
 type StorageBucketCorsRequest = StorageObjectBaseRequest;
@@ -2088,6 +2623,41 @@ interface StorageBucketCorsRuleInput {
 interface StorageSetBucketCorsRequest extends StorageBucketCorsRequest {
     rules: StorageBucketCorsRuleInput[];
 }
+type StorageBucketLifecycleRequest = StorageObjectBaseRequest;
+interface StorageBucketLifecycleRuleInput {
+    id?: string;
+    prefix?: string;
+    status?: 'Enabled' | 'Disabled' | 'enabled' | 'disabled' | (string & {});
+    expiration_days?: number;
+    expired_object_delete_marker?: boolean;
+    noncurrent_version_expiration_days?: number;
+    abort_incomplete_multipart_upload_days?: number;
+}
+interface StorageSetBucketLifecycleRequest extends StorageBucketLifecycleRequest {
+    rules: StorageBucketLifecycleRuleInput[];
+}
+type StorageBucketPolicyRequest = StorageObjectBaseRequest;
+interface StorageSetBucketPolicyRequest extends StorageBucketPolicyRequest {
+    policy: Record<string, unknown> | string;
+}
+type StoragePublicAccessBlockRequest = StorageObjectBaseRequest;
+interface StorageSetPublicAccessBlockRequest extends StoragePublicAccessBlockRequest {
+    block_public_acls?: boolean;
+    ignore_public_acls?: boolean;
+    block_public_policy?: boolean;
+    restrict_public_buckets?: boolean;
+}
+interface StorageFileVersionPathRequest {
+    file_id: string;
+    version_id: string;
+}
+interface StorageFileRetentionRequest {
+    mode?: 'GOVERNANCE' | 'COMPLIANCE' | (string & {});
+    retain_until?: string;
+    retain_until_date?: string;
+    version_id?: string;
+    bypass_governance?: boolean;
+}
 interface StorageAuditQueryRequest {
     file_id?: string;
     limit?: number;
@@ -2206,7 +2776,7 @@ interface StorageUploadUrlResponseWithPut extends Omit<StorageUploadUrlResponse,
 interface StorageBatchUploadUrlResponseWithPut {
     files: StorageUploadUrlResponseWithPut[];
 }
-interface AthenaStorageFileUploadRequest {
+interface AthenaStorageFileUploadRequest extends StorageServerSideEncryptionOptions {
     s3_id?: string;
     s3Id?: string;
     bucket?: string;
@@ -2249,8 +2819,17 @@ interface AthenaStorageFileNamespace extends AthenaStorageFileModule {
     copy(fileId: string, input: CopyStorageFileRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
     url(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageCallOptions): Promise<PresignedFileUrlResponse>;
     publicUrl(fileId: string, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    proxyUrl(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     proxy(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response>;
+    versions(fileId: string, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    restoreVersion(fileId: string, versionId: string, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    deleteVersion(fileId: string, versionId: string, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    retention: {
+        get(fileId: string, query?: Pick<StorageFileRetentionRequest, 'version_id'>, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+        set(fileId: string, input: StorageFileRetentionRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    };
     visibility: {
+        update(fileId: string, input: SetStorageFileVisibilityRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
         set(fileId: string, input: SetStorageFileVisibilityRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
         setMany(input: SetManyStorageFileVisibilityRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationManyResponse>;
     };
@@ -2292,13 +2871,17 @@ interface AthenaStorageObjectNamespace {
     list(input: StorageListObjectsRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     head(input: StorageObjectRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     exists(input: StorageObjectRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
-    validate(input: StorageObjectRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    validate(input: StorageObjectValidateRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     update(input: StorageUpdateObjectRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     copy(input: StorageObjectCopyRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     url(input: StorageObjectRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     publicUrl(input: StorageObjectPublicUrlRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     delete(input: StorageObjectRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     uploadUrl(input: StoragePresignUploadRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    versions(input: StorageObjectVersionListRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    restoreVersion(input: StorageObjectVersionMutationRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    deleteVersion(input: StorageObjectVersionMutationRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    postPolicy(input: StorageSignedPostPolicyRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     folder: AthenaStorageObjectFolderNamespace;
 }
 interface AthenaStorageBucketCorsNamespace {
@@ -2310,6 +2893,21 @@ interface AthenaStorageBucketNamespace {
     list(input: Omit<StorageObjectBaseRequest, 'bucket'>, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     create(input: StorageObjectBaseRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
     delete(input: StorageObjectBaseRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    lifecycle: {
+        get(input: StorageBucketLifecycleRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+        set(input: StorageSetBucketLifecycleRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+        delete(input: StorageBucketLifecycleRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    };
+    policy: {
+        get(input: StorageBucketPolicyRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+        set(input: StorageSetBucketPolicyRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+        delete(input: StorageBucketPolicyRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    };
+    publicAccess: {
+        get(input: StoragePublicAccessBlockRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+        set(input: StorageSetPublicAccessBlockRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+        delete(input: StoragePublicAccessBlockRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    };
     cors: AthenaStorageBucketCorsNamespace;
 }
 interface AthenaStorageMultipartNamespace {
@@ -2335,6 +2933,7 @@ interface AthenaStorageModule extends AthenaStorageBaseModule {
     delete: AthenaStorageFileModule['delete'];
 }
 declare function createAthenaStorageError(input: AthenaStorageErrorInput): AthenaStorageError;
+declare function createStorageModule(gateway: AthenaGatewayClient, runtimeOptions?: AthenaStorageClientConfig): AthenaStorageModule;
 
 type AthenaRowShape$1 = Record<string, AthenaJsonValue | undefined>;
 type FilterColumnKey$1<Row> = Extract<keyof NonNullable<Row>, string>;
@@ -2843,20 +3442,26 @@ interface AthenaSdkClientWithStorage<TStrict extends boolean = false> extends At
     storage: AthenaStorageModule;
 }
 interface AthenaCreateClientServiceUrlConfig {
-    url?: string | null;
+    url?: string | null | undefined;
 }
-interface AthenaCreateClientAuthOptions extends AthenaAuthClientConfig {
-    url?: string | null;
+interface AthenaCreateClientAuthOptions extends Omit<AthenaAuthClientConfig, 'baseUrl' | 'apiKey' | 'bearerToken'> {
+    url?: string | null | undefined;
+    baseUrl?: string | null | undefined;
+    apiKey?: string | null | undefined;
+    bearerToken?: string | null | undefined;
 }
-interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
+interface AthenaCreateClientOptions {
+    client?: string | null | undefined;
+    headers?: Record<string, string>;
+    backend?: BackendConfig | BackendType;
     db?: AthenaCreateClientServiceUrlConfig;
     gateway?: AthenaCreateClientServiceUrlConfig;
     auth?: AthenaCreateClientAuthOptions;
     storage?: AthenaCreateClientServiceUrlConfig;
-    dbUrl?: string | null;
-    gatewayUrl?: string | null;
-    authUrl?: string | null;
-    storageUrl?: string | null;
+    dbUrl?: string | null | undefined;
+    gatewayUrl?: string | null | undefined;
+    authUrl?: string | null | undefined;
+    storageUrl?: string | null | undefined;
     experimental?: AthenaClientExperimentalOptions;
 }
 interface AthenaCreateClientOptionsWithStorage extends AthenaCreateClientOptions {
@@ -2876,30 +3481,30 @@ interface AthenaCreateClientOptionsWithStorageAndTypecheckedColumns extends Athe
     };
 }
 interface AthenaCreateClientConfig extends AthenaCreateClientOptions {
-    url?: string | null;
-    key: string;
+    url?: string | null | undefined;
+    key: string | null | undefined;
 }
 interface AthenaCreateClientConfigWithStorage extends AthenaCreateClientOptionsWithStorage {
-    url?: string | null;
-    key: string;
+    url?: string | null | undefined;
+    key: string | null | undefined;
 }
 interface AthenaCreateClientConfigWithTypecheckedColumns extends AthenaCreateClientOptionsWithTypecheckedColumns {
-    url?: string | null;
-    key: string;
+    url?: string | null | undefined;
+    key: string | null | undefined;
 }
 interface AthenaCreateClientConfigWithStorageAndTypecheckedColumns extends AthenaCreateClientOptionsWithStorageAndTypecheckedColumns {
-    url?: string | null;
-    key: string;
+    url?: string | null | undefined;
+    key: string | null | undefined;
 }
 interface AthenaClientBuilder<StorageEnabled extends boolean = false, TStrict extends boolean = false> {
     /** Set the public Athena base URL. */
-    url(url: string): AthenaClientBuilder<StorageEnabled, TStrict>;
+    url(url: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Set the API key used for all requests. */
-    key(apiKey: string): AthenaClientBuilder<StorageEnabled, TStrict>;
+    key(apiKey: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Set the default backend routing strategy. */
     backend(backend: BackendConfig | BackendType): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Set the default Athena client routing key. */
-    client(clientName: string): AthenaClientBuilder<StorageEnabled, TStrict>;
+    client(clientName: string | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Attach static headers to every request. */
     headers(headers: Record<string, string>): AthenaClientBuilder<StorageEnabled, TStrict>;
     /** Configure Athena Auth client behavior for `client.auth.*` methods. */
@@ -2936,10 +3541,10 @@ declare function createClient(config: AthenaCreateClientConfigWithStorageAndType
 declare function createClient(config: AthenaCreateClientConfigWithStorage): AthenaSdkClientWithStorage<false>;
 declare function createClient(config: AthenaCreateClientConfigWithTypecheckedColumns): AthenaSdkClientWithAuth<true>;
 declare function createClient(config: AthenaCreateClientConfig): AthenaSdkClientWithAuth<false>;
-declare function createClient(url: string, apiKey: string, options: AthenaCreateClientOptionsWithStorageAndTypecheckedColumns): AthenaSdkClientWithStorage<true>;
-declare function createClient(url: string, apiKey: string, options: AthenaCreateClientOptionsWithStorage): AthenaSdkClientWithStorage<false>;
-declare function createClient(url: string, apiKey: string, options: AthenaCreateClientOptionsWithTypecheckedColumns): AthenaSdkClientWithAuth<true>;
-declare function createClient(url: string, apiKey: string, options?: AthenaCreateClientOptions): AthenaSdkClientWithAuth<false>;
+declare function createClient(url: string | null | undefined, apiKey: string | null | undefined, options: AthenaCreateClientOptionsWithStorageAndTypecheckedColumns): AthenaSdkClientWithStorage<true>;
+declare function createClient(url: string | null | undefined, apiKey: string | null | undefined, options: AthenaCreateClientOptionsWithStorage): AthenaSdkClientWithStorage<false>;
+declare function createClient(url: string | null | undefined, apiKey: string | null | undefined, options: AthenaCreateClientOptionsWithTypecheckedColumns): AthenaSdkClientWithAuth<true>;
+declare function createClient(url: string | null | undefined, apiKey: string | null | undefined, options?: AthenaCreateClientOptions): AthenaSdkClientWithAuth<false>;
 
 interface AthenaGatewayErrorInput {
     code: AthenaGatewayErrorCode;
@@ -3034,4 +3639,4 @@ interface ModelFormAdapter<TModel extends AnyModelDef> {
  */
 declare function createModelFormAdapter<TModel extends AnyModelDef>(model: TModel): ModelFormAdapter<TModel>;
 
-export { type AthenaClientExperimentalOptions as $, type AthenaAdminListUsersFilterOperator as A, type AthenaAuthQueryValue as B, type AthenaAuthReactEmailComponent as C, type AthenaAuthReactEmailConfig as D, type AthenaAuthReactEmailEventPhase as E, type AthenaAuthReactEmailProps as F, type AthenaAuthReactEmailRenderEvent as G, type AthenaAuthReactEmailRenderInput as H, type AthenaAuthReactEmailRenderOptions as I, type AthenaAuthRequestInput as J, type AthenaAuthResetPasswordBinding as K, type AthenaAuthResult as L, type AthenaAuthRevokeSessionRequest as M, type AthenaAuthSdkClient as N, type AthenaAuthSearchOperator as O, type AthenaAuthSession as P, type AthenaAuthSessionResponse as Q, type AthenaAuthSessionRevokeBinding as R, type AthenaAuthSignInResponse as S, type AthenaAuthSignOutResponse as T, type AthenaAuthSocialRedirectResponse as U, type AthenaAuthStatusResponse as V, type AthenaAuthUser as W, type AthenaChangeEmailRequest as X, type AthenaChangePasswordRequest as Y, AthenaClient as Z, type AthenaClientBuilder as _, type AthenaAdminListUsersQuery as a, type AthenaStorageFileConfig as a$, type AthenaCreateClientAuthOptions as a0, type AthenaCreateClientConfig as a1, type AthenaCreateClientConfigWithStorage as a2, type AthenaCreateClientConfigWithStorageAndTypecheckedColumns as a3, type AthenaCreateClientConfigWithTypecheckedColumns as a4, type AthenaCreateClientOptions as a5, type AthenaCreateClientOptionsWithStorage as a6, type AthenaCreateClientOptionsWithStorageAndTypecheckedColumns as a7, type AthenaCreateClientOptionsWithTypecheckedColumns as a8, type AthenaCreateClientServiceUrlConfig as a9, type AthenaQueryTraceCallsite as aA, type AthenaQueryTraceEvent as aB, type AthenaQueryTraceOptions as aC, type AthenaRawQueryDebugAst as aD, type AthenaRelationSelectNode as aE, type AthenaResetPasswordRequest as aF, type AthenaResult as aG, type AthenaResultError as aH, type AthenaRpcBuilderStateAst as aI, type AthenaRpcDebugAst as aJ, type AthenaSdkClient as aK, type AthenaSdkClientWithAuth as aL, type AthenaSdkClientWithStorage as aM, type AthenaSelectDebugAst as aN, type AthenaSelectDebugTransport as aO, type AthenaSelectShape as aP, type AthenaSendVerificationEmailRequest as aQ, type AthenaSocialSignInRequest as aR, type AthenaStorageBinaryCallOptions as aS, type AthenaStorageCallOptions as aT, type AthenaStorageClientConfig as aU, type AthenaStorageEnv as aV, AthenaStorageError as aW, AthenaStorageErrorCode as aX, type AthenaStorageErrorDetails as aY, type AthenaStorageErrorHandler as aZ, type AthenaStorageErrorInput as a_, type AthenaDbModule as aa, type AthenaDeleteDebugAst as ab, type AthenaDeleteUserCallbackRequest as ac, type AthenaDeleteUserRequest as ad, type AthenaDeleteUserResponse as ae, type AthenaEmailSignInRequest as af, type AthenaEmailSignUpRequest as ag, type AthenaEnvelope as ah, AthenaError as ai, AthenaErrorCategory as aj, AthenaErrorCode as ak, type AthenaErrorInput as al, AthenaErrorKind as am, type AthenaFindManyDebugAst as an, type AthenaFindManyOptions as ao, type AthenaFindManyResult as ap, type AthenaForgetPasswordRequest as aq, type AthenaFromOptions as ar, AthenaGatewayError as as, type AthenaInsertDebugAst as at, type AthenaLinkSocialRequest as au, type AthenaOAuthAccountTokenRequest as av, type AthenaOAuthTokenBundle as aw, type AthenaOperationContext as ax, type AthenaOrderBy as ay, type AthenaQueryDebugAst as az, type AthenaAdminListUsersSearchOperator as b, assertInt as b$, type AthenaStorageFileDeleteInput as b0, type AthenaStorageFileDownloadInput as b1, type AthenaStorageFileListInput as b2, type AthenaStorageFileModule as b3, type AthenaStorageFileUploadInput as b4, type AthenaStorageFileUploadResult as b5, type AthenaStorageModule as b6, type AthenaStoragePathContext as b7, type AthenaStoragePrefixPath as b8, type AthenaStorageTemplateValue as b9, type ModelFormDefaults as bA, type ModelFormNullishMode as bB, type ModelFormValues as bC, type MoveStorageFolderRequest as bD, type NormalizedAthenaError as bE, type PresignedFileUrlResponse as bF, type RequireAffectedOptions as bG, type RetryBackoffStrategy as bH, type RetryConfig as bI, type RpcOrderOptions as bJ, type RpcQueryBuilder as bK, type S3CatalogItem as bL, type S3CredentialListItem as bM, type SetStorageFileVisibilityRequest as bN, type StorageBatchUploadUrlResponse as bO, type StorageFileAccessPurpose as bP, type StorageFileMutationResponse as bQ, type StorageFolderMutationResponse as bR, type StorageListFilesResponse as bS, type StorageUploadUrlResponse as bT, type TableQueryBuilder as bU, type ToModelFormDefaultsOptions as bV, type ToModelPayloadOptions as bW, type UnwrapOneOptions as bX, type UnwrapOptions as bY, type UpdateStorageCatalogRequest as bZ, type UpdateStorageFileRequest as b_, type AthenaStorageTemplateVars as ba, type AthenaStorageUploadConstraints as bb, type AthenaStorageUploadProgress as bc, type AthenaStorageUploadProgressHandler as bd, type AthenaStorageUploadSource as be, type AthenaStorageUploadedFile as bf, type AthenaTableBuilderStateAst as bg, type AthenaUnlinkAccountRequest as bh, type AthenaUpdateDebugAst as bi, type AthenaUpdateUserRequest as bj, type AthenaUpsertDebugAst as bk, type AthenaUsernameSignInRequest as bl, type AthenaVerifyEmailRequest as bm, type AthenaWhere as bn, type AthenaWhereBooleanOperand as bo, type AthenaWhereOperatorInput as bp, type CreateStorageCatalogRequest as bq, type CreateStorageUploadUrlRequest as br, type CreateStorageUploadUrlsRequest as bs, type DeleteStorageFolderRequest as bt, type FormValuesOf as bu, type GetStorageFileUrlQuery as bv, type IntCoercionOptions as bw, type ListStorageFilesRequest as bx, type ManagedFileRecord as by, type ModelFormAdapter as bz, type AthenaAuthAdminUserSessionRevokeBinding as c, coerceInt as c0, createAthenaStorageError as c1, createClient as c2, createModelFormAdapter as c3, getAthenaDebugAst as c4, isAthenaGatewayError as c5, isOk as c6, normalizeAthenaError as c7, parseBooleanFlag as c8, requireAffected as c9, requireSuccess as ca, storageSdkManifest as cb, toModelFormDefaults as cc, toModelPayload as cd, unwrap as ce, unwrapOne as cf, unwrapRows as cg, withRetry as ch, type AthenaAuthFetchCompatibleInput as ci, type AthenaAuthBindings as d, type AthenaAuthCallOptions as e, type AthenaAuthClientConfig as f, type AthenaAuthCredentials as g, type AthenaAuthEmailChangeResponse as h, type AthenaAuthEmailTemplateBuilder as i, type AthenaAuthEmailTemplateCreateFromDefinitionInput as j, type AthenaAuthEmailTemplateDefinition as k, type AthenaAuthEmailTemplateReactOverrides as l, type AthenaAuthEmailTemplateUpdateFromDefinitionInput as m, type AthenaAuthEndpointPath as n, type AthenaAuthErrorCode as o, type AthenaAuthErrorDetails as p, type AthenaAuthFilterOperator as q, type AthenaAuthGenericInput as r, type AthenaAuthGenericQueryInput as s, type AthenaAuthLinkedAccount as t, type AthenaAuthMethod as u, type AthenaAuthOrganization as v, type AthenaAuthOrganizationBindings as w, type AthenaAuthOrganizationInvitation as x, type AthenaAuthOrganizationMember as y, type AthenaAuthQueryPrimitive as z };
+export { type AthenaClientExperimentalOptions as $, type AthenaAdminListUsersFilterOperator as A, type AthenaAuthQueryValue as B, type AthenaAuthReactEmailComponent as C, type AthenaAuthReactEmailConfig as D, type AthenaAuthReactEmailEventPhase as E, type AthenaAuthReactEmailProps as F, type AthenaAuthReactEmailRenderEvent as G, type AthenaAuthReactEmailRenderInput as H, type AthenaAuthReactEmailRenderOptions as I, type AthenaAuthRequestInput as J, type AthenaAuthResetPasswordBinding as K, type AthenaAuthResult as L, type AthenaAuthRevokeSessionRequest as M, type AthenaAuthSdkClient as N, type AthenaAuthSearchOperator as O, type AthenaAuthSession as P, type AthenaAuthSessionResponse as Q, type AthenaAuthSessionRevokeBinding as R, type AthenaAuthSignInResponse as S, type AthenaAuthSignOutResponse as T, type AthenaAuthSocialRedirectResponse as U, type AthenaAuthStatusResponse as V, type AthenaAuthUser as W, type AthenaChangeEmailRequest as X, type AthenaChangePasswordRequest as Y, AthenaClient as Z, type AthenaClientBuilder as _, type AthenaAdminListUsersQuery as a, type AthenaStorageEnv as a$, type AthenaCreateClientAuthOptions as a0, type AthenaCreateClientConfig as a1, type AthenaCreateClientConfigWithStorage as a2, type AthenaCreateClientConfigWithStorageAndTypecheckedColumns as a3, type AthenaCreateClientConfigWithTypecheckedColumns as a4, type AthenaCreateClientOptions as a5, type AthenaCreateClientOptionsWithStorage as a6, type AthenaCreateClientOptionsWithStorageAndTypecheckedColumns as a7, type AthenaCreateClientOptionsWithTypecheckedColumns as a8, type AthenaCreateClientServiceUrlConfig as a9, type AthenaQueryTraceCallsite as aA, type AthenaQueryTraceEvent as aB, type AthenaQueryTraceOptions as aC, type AthenaRawQueryDebugAst as aD, type AthenaRelationSelectNode as aE, type AthenaResetPasswordRequest as aF, type AthenaResult as aG, type AthenaResultError as aH, type AthenaRpcBuilderStateAst as aI, type AthenaRpcDebugAst as aJ, type AthenaSdkClient as aK, type AthenaSdkClientWithAuth as aL, type AthenaSdkClientWithStorage as aM, type AthenaSelectDebugAst as aN, type AthenaSelectDebugTransport as aO, type AthenaSelectShape as aP, type AthenaSendVerificationEmailRequest as aQ, type AthenaSocialSignInRequest as aR, type AthenaStorageAuditNamespace as aS, type AthenaStorageBaseModule as aT, type AthenaStorageBinaryCallOptions as aU, type AthenaStorageBucketCorsNamespace as aV, type AthenaStorageBucketNamespace as aW, type AthenaStorageCallOptions as aX, type AthenaStorageCatalogNamespace as aY, type AthenaStorageClientConfig as aZ, type AthenaStorageCredentialsNamespace as a_, type AthenaDbModule as aa, type AthenaDeleteDebugAst as ab, type AthenaDeleteUserCallbackRequest as ac, type AthenaDeleteUserRequest as ad, type AthenaDeleteUserResponse as ae, type AthenaEmailSignInRequest as af, type AthenaEmailSignUpRequest as ag, type AthenaEnvelope as ah, AthenaError as ai, AthenaErrorCategory as aj, AthenaErrorCode as ak, type AthenaErrorInput as al, AthenaErrorKind as am, type AthenaFindManyDebugAst as an, type AthenaFindManyOptions as ao, type AthenaFindManyResult as ap, type AthenaForgetPasswordRequest as aq, type AthenaFromOptions as ar, AthenaGatewayError as as, type AthenaInsertDebugAst as at, type AthenaLinkSocialRequest as au, type AthenaOAuthAccountTokenRequest as av, type AthenaOAuthTokenBundle as aw, type AthenaOperationContext as ax, type AthenaOrderBy as ay, type AthenaQueryDebugAst as az, type AthenaAdminListUsersSearchOperator as b, type RequireAffectedOptions as b$, AthenaStorageError as b0, AthenaStorageErrorCode as b1, type AthenaStorageErrorDetails as b2, type AthenaStorageErrorHandler as b3, type AthenaStorageErrorInput as b4, type AthenaStorageFileConfig as b5, type AthenaStorageFileDeleteInput as b6, type AthenaStorageFileDownloadInput as b7, type AthenaStorageFileListInput as b8, type AthenaStorageFileModule as b9, type AthenaUpdateUserRequest as bA, type AthenaUpsertDebugAst as bB, type AthenaUsernameSignInRequest as bC, type AthenaVerifyEmailRequest as bD, type AthenaWhere as bE, type AthenaWhereBooleanOperand as bF, type AthenaWhereOperatorInput as bG, type ConfirmStorageUploadRequest as bH, type CopyStorageFileRequest as bI, type CreateStorageCatalogRequest as bJ, type CreateStorageUploadUrlRequest as bK, type CreateStorageUploadUrlsRequest as bL, type DeleteManyStorageFilesRequest as bM, type DeleteStorageFolderRequest as bN, type FormValuesOf as bO, type GetStorageFileUrlQuery as bP, type IntCoercionOptions as bQ, type ListStorageFilesRequest as bR, type ListStorageFoldersRequest as bS, type ManagedFileRecord as bT, type ModelFormAdapter as bU, type ModelFormDefaults as bV, type ModelFormNullishMode as bW, type ModelFormValues as bX, type MoveStorageFolderRequest as bY, type NormalizedAthenaError as bZ, type PresignedFileUrlResponse as b_, type AthenaStorageFileNamespace as ba, type AthenaStorageFileUploadInput as bb, type AthenaStorageFileUploadManyRequest as bc, type AthenaStorageFileUploadRequest as bd, type AthenaStorageFileUploadResult as be, type AthenaStorageFolderNamespace as bf, type AthenaStorageManagedUpload as bg, type AthenaStorageModule as bh, type AthenaStorageMultipartNamespace as bi, type AthenaStorageObjectFolderNamespace as bj, type AthenaStorageObjectNamespace as bk, type AthenaStoragePathContext as bl, type AthenaStoragePermissionNamespace as bm, type AthenaStoragePrefixPath as bn, type AthenaStoragePutBody as bo, type AthenaStoragePutOptions as bp, type AthenaStorageTemplateValue as bq, type AthenaStorageTemplateVars as br, type AthenaStorageUploadConstraints as bs, type AthenaStorageUploadProgress as bt, type AthenaStorageUploadProgressHandler as bu, type AthenaStorageUploadSource as bv, type AthenaStorageUploadedFile as bw, type AthenaTableBuilderStateAst as bx, type AthenaUnlinkAccountRequest as by, type AthenaUpdateDebugAst as bz, type AthenaAuthAdminUserSessionRevokeBinding as c, type ToModelPayloadOptions as c$, type RetryBackoffStrategy as c0, type RetryConfig as c1, type RpcOrderOptions as c2, type RpcQueryBuilder as c3, type S3CatalogItem as c4, type S3CredentialListItem as c5, type SearchStorageFilesRequest as c6, type SetManyStorageFileVisibilityRequest as c7, type SetStorageFileVisibilityRequest as c8, type StorageAuditEventRecord as c9, type StorageObjectFolderCreateRequest as cA, type StorageObjectFolderDeleteRequest as cB, type StorageObjectFolderRenameRequest as cC, type StorageObjectPublicUrlRequest as cD, type StorageObjectRequest as cE, type StorageObjectValidateRequest as cF, type StorageObjectVersionListRequest as cG, type StorageObjectVersionMutationRequest as cH, type StoragePermissionCheckRequest as cI, type StoragePermissionCheckResponse as cJ, type StoragePermissionGrantRequest as cK, type StoragePermissionListRequest as cL, type StoragePermissionListResponse as cM, type StoragePermissionRevokeRequest as cN, type StoragePresignUploadRequest as cO, type StoragePublicAccessBlockRequest as cP, type StorageServerSideEncryptionOptions as cQ, type StorageSetBucketCorsRequest as cR, type StorageSetBucketLifecycleRequest as cS, type StorageSetBucketPolicyRequest as cT, type StorageSetPublicAccessBlockRequest as cU, type StorageSignedPostPolicyRequest as cV, type StorageUpdateObjectRequest as cW, type StorageUploadUrlResponse as cX, type StorageUploadUrlResponseWithPut as cY, type TableQueryBuilder as cZ, type ToModelFormDefaultsOptions as c_, type StorageAuditListResponse as ca, type StorageAuditQueryRequest as cb, type StorageBatchUploadUrlResponse as cc, type StorageBatchUploadUrlResponseWithPut as cd, type StorageBucketCorsRequest as ce, type StorageBucketCorsRuleInput as cf, type StorageBucketLifecycleRequest as cg, type StorageBucketLifecycleRuleInput as ch, type StorageBucketPolicyRequest as ci, type StorageFileAccessPurpose as cj, type StorageFileMutationManyResponse as ck, type StorageFileMutationResponse as cl, type StorageFilePermissionRecord as cm, type StorageFileRetentionRequest as cn, type StorageFileVersionPathRequest as co, type StorageFolderMutationResponse as cp, type StorageListFilesResponse as cq, type StorageListObjectsRequest as cr, type StorageMultipartAbortRequest as cs, type StorageMultipartCompletePartInput as ct, type StorageMultipartCompleteRequest as cu, type StorageMultipartCreateRequest as cv, type StorageMultipartListPartsRequest as cw, type StorageMultipartSignPartRequest as cx, type StorageObjectBaseRequest as cy, type StorageObjectCopyRequest as cz, type AthenaAuthBindings as d, type TreeStorageFoldersRequest as d0, type UnwrapOneOptions as d1, type UnwrapOptions as d2, type UpdateManyStorageFilesRequest as d3, type UpdateStorageCatalogRequest as d4, type UpdateStorageFileRequest as d5, assertInt as d6, coerceInt as d7, createAthenaStorageError as d8, createClient as d9, createModelFormAdapter as da, createStorageModule as db, getAthenaDebugAst as dc, isAthenaGatewayError as dd, isOk as de, normalizeAthenaError as df, parseBooleanFlag as dg, requireAffected as dh, requireSuccess as di, storageSdkManifest as dj, toModelFormDefaults as dk, toModelPayload as dl, unwrap as dm, unwrapOne as dn, unwrapRows as dp, verifyAthenaGatewayUrl as dq, withRetry as dr, type AthenaAuthFetchCompatibleInput as ds, type AthenaAuthCallOptions as e, type AthenaAuthClientConfig as f, type AthenaAuthCredentials as g, type AthenaAuthEmailChangeResponse as h, type AthenaAuthEmailTemplateBuilder as i, type AthenaAuthEmailTemplateCreateFromDefinitionInput as j, type AthenaAuthEmailTemplateDefinition as k, type AthenaAuthEmailTemplateReactOverrides as l, type AthenaAuthEmailTemplateUpdateFromDefinitionInput as m, type AthenaAuthEndpointPath as n, type AthenaAuthErrorCode as o, type AthenaAuthErrorDetails as p, type AthenaAuthFilterOperator as q, type AthenaAuthGenericInput as r, type AthenaAuthGenericQueryInput as s, type AthenaAuthLinkedAccount as t, type AthenaAuthMethod as u, type AthenaAuthOrganization as v, type AthenaAuthOrganizationBindings as w, type AthenaAuthOrganizationInvitation as x, type AthenaAuthOrganizationMember as y, type AthenaAuthQueryPrimitive as z };