@xylex-group/athena 2.8.0 → 2.9.0

package/dist/{model-form-DMed05gE.d.cts → client-CfAE_QOj.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.cjs';
+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, $ as AthenaQueryPayload, Z 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 } from './types-BeZIHduP.cjs';
 
 type AthenaAuthMethod = 'GET' | 'POST';
 type AthenaAuthCredentials = 'omit' | 'same-origin' | 'include';
@@ -56,6 +56,9 @@ interface AthenaAuthSessionResponse {
     session: AthenaAuthSession;
     user: AthenaAuthUser;
 }
+interface AthenaAuthGetUserResponse {
+    user: AthenaAuthUser | null;
+}
 interface AthenaAuthOrganization {
     id: string;
     name: string;
@@ -858,6 +861,9 @@ interface AthenaAuthCallOptions {
     baseUrl?: string;
     apiKey?: string;
     bearerToken?: string;
+    cookie?: string;
+    sessionToken?: string;
+    forceNoCache?: boolean;
     headers?: Record<string, string>;
     credentials?: AthenaAuthCredentials;
     signal?: AbortSignal;
@@ -869,6 +875,20 @@ interface AthenaAuthClientConfig extends AthenaAuthCallOptions {
     fetch?: typeof fetch;
     reactEmail?: AthenaAuthReactEmailConfig;
 }
+type AthenaAuthGuardReason = 'unauthorized' | 'forbidden' | 'upstream_error';
+interface AthenaAuthGuardSuccess {
+    ok: true;
+    session: AthenaAuthSessionResponse;
+}
+interface AthenaAuthGuardFailure {
+    ok: false;
+    reason: AthenaAuthGuardReason;
+    status: number;
+    error: string;
+    sessionResult?: AthenaAuthResult<AthenaAuthSessionResponse>;
+    permissionResult?: AthenaAuthResult<AthenaAdminHasPermissionResponse>;
+}
+type AthenaAuthGuardResult = AthenaAuthGuardSuccess | AthenaAuthGuardFailure;
 interface AthenaAuthEmailTemplateDefinition<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps> {
     component: AthenaAuthReactEmailComponent<TProps>;
     templateKey?: string;
@@ -943,6 +963,8 @@ interface AthenaAuthOrganizationBindings {
     } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganizationInvitation[]>>;
     /** Check organization-level permissions for the current principal. Route: `POST /organization/has-permission`. */
     hasPermission: (input: AthenaAdminHasPermissionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminHasPermissionResponse>>;
+    /** Resolve the current session and require organization-level permissions in one call. */
+    requirePermission: (input: AthenaAdminHasPermissionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthGuardResult>;
     invitation: {
         /** Cancel an organization invitation. Route: `POST /organization/cancel-invitation`. */
         cancel: (input: AthenaAuthOrganizationInvitationActionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
@@ -977,6 +999,10 @@ interface AthenaAuthOrganizationBindings {
 interface AthenaAuthBindings {
     /** Get current session. Route: `GET /get-session`. */
     getSession: AthenaAuthSdkClient['getSession'];
+    /** Get current user as a Better Auth-style compatibility projection. Route: `GET /get-session`. */
+    getUser: AthenaAuthSdkClient['getUser'];
+    /** Resolve the current session into a typed guard result. */
+    requireSession: AthenaAuthSdkClient['requireSession'];
     /** Sign out current session. Route: `POST /sign-out`. */
     signOut: AthenaAuthSdkClient['signOut'];
     /** Trigger password reset email flow. Route: `POST /forget-password`. */
@@ -1122,6 +1148,8 @@ interface AthenaAuthBindings {
         };
         /** Check permission under admin policy. Route: `POST /admin/has-permission`. */
         hasPermission: (input: AthenaAdminHasPermissionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminHasPermissionResponse>>;
+        /** Resolve the current session and require admin permissions in one call. */
+        requirePermission: (input: AthenaAdminHasPermissionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthGuardResult>;
         apiKey: {
             /** Create admin-scoped API key. Route: `POST /admin/api-key/create`. */
             create: (input?: AthenaAdminApiKeyCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminApiKeyCreateResponse>>;
@@ -1254,6 +1282,8 @@ interface AthenaAuthSdkClient {
     signOut: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignOutResponse>>;
     logout: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignOutResponse>>;
     getSession: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSessionResponse>>;
+    getUser: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthGetUserResponse>>;
+    requireSession: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthGuardResult>;
     listSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSession[]>>;
     revokeSession: (input: AthenaAuthRevokeSessionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
     clearSession: (input: AthenaAuthRevokeSessionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
@@ -1463,6 +1493,10 @@ declare function coerceInt(value: unknown, options?: IntCoercionOptions): number
  */
 declare function assertInt(value: unknown, label?: string, options?: IntCoercionOptions): number;
 /**
+ * @deprecated Prefer `experimental.retryReads` for standard SDK-managed read
+ * retries, or a call-site retry policy when you need custom write/replay
+ * behavior. This helper is retained for compatibility.
+ *
  * Retries an async operation with configurable backoff and retry policy.
  *
  * `retries` represents additional attempts after the first failure.
@@ -1510,6 +1544,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 +1610,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 +1784,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 +1813,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 +2295,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 +2338,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 +2365,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 +2474,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 +2547,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 +2596,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 +2624,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 +2657,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 +2810,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 +2853,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 +2905,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 +2927,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 +2967,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>;
@@ -2835,28 +3468,59 @@ interface AthenaSdkClient<TStrict extends boolean = false> {
     rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row, TStrict>;
     query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
     verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+    withContext(context?: AthenaClientContextOptions): AthenaSdkClient<TStrict>;
+    withSession(session?: AthenaClientSessionLike | null, options?: AthenaClientSessionOptions): AthenaSdkClient<TStrict>;
 }
 interface AthenaSdkClientWithAuth<TStrict extends boolean = false> extends AthenaSdkClient<TStrict> {
     auth: AthenaAuthBindings;
+    withContext(context?: AthenaClientContextOptions): AthenaSdkClientWithAuth<TStrict>;
+    withSession(session?: AthenaClientSessionLike | null, options?: AthenaClientSessionOptions): AthenaSdkClientWithAuth<TStrict>;
+    withOptions(options?: AthenaClientOverrideOptions): AthenaSdkClientWithAuth<TStrict>;
 }
 interface AthenaSdkClientWithStorage<TStrict extends boolean = false> extends AthenaSdkClientWithAuth<TStrict> {
     storage: AthenaStorageModule;
+    withContext(context?: AthenaClientContextOptions): AthenaSdkClientWithStorage<TStrict>;
+    withSession(session?: AthenaClientSessionLike | null, options?: AthenaClientSessionOptions): AthenaSdkClientWithStorage<TStrict>;
+    withOptions(options?: AthenaClientOverrideOptions): AthenaSdkClientWithStorage<TStrict>;
+}
+interface AthenaHeaderBag {
+    get(name: string): string | null;
+}
+interface AthenaClientSessionLike {
+    user?: {
+        id?: string | null | undefined;
+    } | null | undefined;
+    session?: {
+        token?: string | null | undefined;
+        activeOrganizationId?: string | null | undefined;
+    } | null | undefined;
 }
 interface AthenaCreateClientServiceUrlConfig {
-    url?: string | null;
-}
-interface AthenaCreateClientAuthOptions extends AthenaAuthClientConfig {
-    url?: string | null;
-}
-interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
+    url?: string | null | undefined;
+}
+interface AthenaCreateClientAuthOptions extends Omit<AthenaAuthClientConfig, 'baseUrl' | 'apiKey' | 'bearerToken' | 'cookie' | 'sessionToken'> {
+    url?: string | null | undefined;
+    baseUrl?: string | null | undefined;
+    apiKey?: string | null | undefined;
+    bearerToken?: string | null | undefined;
+    cookie?: string | null | undefined;
+    sessionToken?: string | null | undefined;
+}
+interface AthenaCreateClientOptions {
+    client?: string | null | undefined;
+    userId?: string | null | undefined;
+    organizationId?: string | null | undefined;
+    forceNoCache?: boolean;
+    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 +3540,65 @@ 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 AthenaClientOverrideOptions extends Omit<AthenaCreateClientOptions, 'experimental'> {
+    url?: string | null | undefined;
+    key?: string | null | undefined;
+}
+interface AthenaClientContextOptions {
+    userId?: string | null | undefined;
+    organizationId?: string | null | undefined;
+    forceNoCache?: boolean;
+    headers?: Record<string, string>;
+    auth?: Omit<AthenaCreateClientAuthOptions, 'url' | 'baseUrl' | 'apiKey'>;
+}
+interface AthenaClientSessionOptions extends AthenaClientContextOptions {
+    requestHeaders?: AthenaHeaderBag | Record<string, string | null | undefined>;
+}
+interface AthenaClientFromEnvironmentOptions extends AthenaCreateClientOptions {
+    env?: Record<string, string | undefined>;
+    url?: string | null | undefined;
+    key?: string | null | undefined;
+}
+interface AthenaClientFromEnvironmentOptionsWithStorage extends AthenaClientFromEnvironmentOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+    };
+}
+interface AthenaClientFromEnvironmentOptionsWithTypecheckedColumns extends AthenaClientFromEnvironmentOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        typecheckColumns: true;
+    };
+}
+interface AthenaClientFromEnvironmentOptionsWithStorageAndTypecheckedColumns extends AthenaClientFromEnvironmentOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+        typecheckColumns: true;
+    };
 }
 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. */
@@ -2929,109 +3628,19 @@ declare class AthenaClient {
     /** Create a fluent builder for a strongly-typed Athena SDK client. */
     static builder(): AthenaClientBuilder<false, false>;
     /** Build a client from process environment variables. */
-    static fromEnvironment(): AthenaSdkClientWithAuth<false>;
+    static fromEnvironment(options: AthenaClientFromEnvironmentOptionsWithStorageAndTypecheckedColumns): AthenaSdkClientWithStorage<true>;
+    static fromEnvironment(options: AthenaClientFromEnvironmentOptionsWithStorage): AthenaSdkClientWithStorage<false>;
+    static fromEnvironment(options: AthenaClientFromEnvironmentOptionsWithTypecheckedColumns): AthenaSdkClientWithAuth<true>;
+    static fromEnvironment(options?: AthenaClientFromEnvironmentOptions): AthenaSdkClientWithAuth<false>;
 }
 /** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
 declare function createClient(config: AthenaCreateClientConfigWithStorageAndTypecheckedColumns): AthenaSdkClientWithStorage<true>;
 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>;
-
-interface AthenaGatewayErrorInput {
-    code: AthenaGatewayErrorCode;
-    message: string;
-    status?: number;
-    endpoint?: AthenaGatewayEndpointPath;
-    method?: AthenaGatewayMethod;
-    requestId?: string;
-    hint?: string;
-    cause?: string;
-}
-/**
- * Canonical error for gateway failures.
- * Holds request context and machine-readable classification.
- */
-declare class AthenaGatewayError extends Error {
-    readonly code: AthenaGatewayErrorCode;
-    readonly status: number;
-    readonly endpoint?: AthenaGatewayEndpointPath;
-    readonly method?: AthenaGatewayMethod;
-    readonly requestId?: string;
-    readonly hint?: string;
-    readonly causeDetail?: string;
-    constructor(input: AthenaGatewayErrorInput);
-    toDetails(): AthenaGatewayErrorDetails;
-    static fromResponse<T>(response: AthenaGatewayResponse<T>, fallback: Omit<AthenaGatewayErrorInput, 'code' | 'message' | 'status'>): AthenaGatewayError;
-}
-declare function isAthenaGatewayError(error: unknown): error is AthenaGatewayError;
-
-type ModelFormNullishMode = 'empty-string' | 'undefined' | 'null';
-type NullishValueByMode = {
-    'empty-string': '';
-    undefined: undefined;
-    null: null;
-};
-type MapNullableToFormValue<TField, TMode extends ModelFormNullishMode> = null extends TField ? Exclude<TField, null> | NullishValueByMode[TMode] : TField;
-/**
- * Form value shape derived from a model insert payload.
- * Nullable fields are remapped to the selected nullish representation.
- */
-type ModelFormValues<TModel extends AnyModelDef, TMode extends ModelFormNullishMode = 'empty-string'> = {
-    [K in keyof InsertOf<TModel>]: MapNullableToFormValue<InsertOf<TModel>[K], TMode>;
-};
-/**
- * Alias for deriving form value types from any model contract.
- */
-type FormValuesOf<TModel extends AnyModelDef, TMode extends ModelFormNullishMode = 'empty-string'> = ModelFormValues<TModel, TMode>;
-/**
- * Default value shape for form initialization.
- */
-type ModelFormDefaults<TModel extends AnyModelDef, TMode extends ModelFormNullishMode = 'empty-string'> = Partial<ModelFormValues<TModel, TMode>>;
-interface ToModelFormDefaultsOptions<TMode extends ModelFormNullishMode = 'empty-string'> {
-    /**
-     * Controls how nullable model values are represented in form defaults.
-     * - `empty-string` (default): `null -> ""`
-     * - `undefined`: `null -> undefined`
-     * - `null`: keeps `null`
-     */
-    nullishMode?: TMode;
-}
-interface ToModelPayloadOptions {
-    /**
-     * Converts `""` into `null` for nullable model fields.
-     * Defaults to `true`.
-     */
-    emptyStringAsNull?: boolean;
-    /**
-     * Omits `undefined` keys from the outgoing payload.
-     * Defaults to `true`.
-     */
-    stripUndefined?: boolean;
-}
-/**
- * Normalizes model data into form-safe defaults using model nullability metadata.
- */
-declare function toModelFormDefaults<TModel extends AnyModelDef, TMode extends ModelFormNullishMode = 'empty-string'>(model: TModel, values?: Partial<RowOf<TModel>> | Partial<InsertOf<TModel>> | null, options?: ToModelFormDefaultsOptions<TMode>): ModelFormDefaults<TModel, TMode>;
-/**
- * Normalizes form values back into model-compatible insert/update payloads.
- */
-declare function toModelPayload<TModel extends AnyModelDef>(model: TModel, formValues: Partial<ModelFormValues<TModel, 'empty-string' | 'undefined' | 'null'>>, options?: ToModelPayloadOptions): Partial<InsertOf<TModel>>;
-/**
- * Runtime form adapter bound to a model contract.
- */
-interface ModelFormAdapter<TModel extends AnyModelDef> {
-    model: TModel;
-    toDefaults<TMode extends ModelFormNullishMode = 'empty-string'>(values?: Partial<RowOf<TModel>> | Partial<InsertOf<TModel>> | null, options?: ToModelFormDefaultsOptions<TMode>): ModelFormDefaults<TModel, TMode>;
-    toInsert(values: Partial<ModelFormValues<TModel, 'empty-string' | 'undefined' | 'null'>>, options?: ToModelPayloadOptions): Partial<InsertOf<TModel>>;
-    toUpdate(values: Partial<ModelFormValues<TModel, 'empty-string' | 'undefined' | 'null'>>, options?: ToModelPayloadOptions): Partial<UpdateOf<TModel>>;
-}
-/**
- * Creates a small model-aware adapter for form defaults and payload normalization.
- */
-declare function createModelFormAdapter<TModel extends AnyModelDef>(model: TModel): ModelFormAdapter<TModel>;
+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>;
 
-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 AthenaAuthOrganizationMember as $, type AthenaAdminEmailCreateRequest as A, type AthenaAuthBindings as B, type AthenaAuthCallOptions as C, type AthenaAuthClientConfig as D, type AthenaAuthCredentials as E, type AthenaAuthEmailChangeResponse as F, type AthenaAuthEmailTemplateBuilder as G, type AthenaAuthEmailTemplateCreateFromDefinitionInput as H, type AthenaAuthEmailTemplateDefinition as I, type AthenaAuthEmailTemplateReactOverrides as J, type AthenaAuthEmailTemplateUpdateFromDefinitionInput as K, type AthenaAuthEndpointPath as L, type AthenaAuthErrorCode as M, type AthenaAuthErrorDetails as N, type AthenaAuthFilterOperator as O, type AthenaAuthGenericInput as P, type AthenaAuthGenericQueryInput as Q, type AthenaAuthGetUserResponse as R, type AthenaAuthGuardFailure as S, type AthenaAuthGuardReason as T, type AthenaAuthGuardResult as U, type AthenaAuthGuardSuccess as V, type AthenaAuthLinkedAccount as W, type AthenaAuthMethod as X, type AthenaAuthOrganization as Y, type AthenaAuthOrganizationBindings as Z, type AthenaAuthOrganizationInvitation as _, type AthenaAdminEmailDeleteRequest as a, type AthenaFromOptions as a$, type AthenaAuthQueryPrimitive as a0, type AthenaAuthQueryValue as a1, type AthenaAuthReactEmailComponent as a2, type AthenaAuthReactEmailConfig as a3, type AthenaAuthReactEmailEventPhase as a4, type AthenaAuthReactEmailProps as a5, type AthenaAuthReactEmailRenderEvent as a6, type AthenaAuthReactEmailRenderInput as a7, type AthenaAuthReactEmailRenderOptions as a8, type AthenaAuthRequestInput as a9, type AthenaCreateClientAuthOptions as aA, type AthenaCreateClientConfig as aB, type AthenaCreateClientConfigWithStorage as aC, type AthenaCreateClientConfigWithStorageAndTypecheckedColumns as aD, type AthenaCreateClientConfigWithTypecheckedColumns as aE, type AthenaCreateClientOptions as aF, type AthenaCreateClientOptionsWithStorage as aG, type AthenaCreateClientOptionsWithStorageAndTypecheckedColumns as aH, type AthenaCreateClientOptionsWithTypecheckedColumns as aI, type AthenaCreateClientServiceUrlConfig as aJ, type AthenaDbModule as aK, type AthenaDeleteDebugAst as aL, type AthenaDeleteUserCallbackRequest as aM, type AthenaDeleteUserRequest as aN, type AthenaDeleteUserResponse as aO, type AthenaEmailSignInRequest as aP, type AthenaEmailSignUpRequest as aQ, type AthenaEnvelope as aR, AthenaError as aS, AthenaErrorCategory as aT, AthenaErrorCode as aU, type AthenaErrorInput as aV, AthenaErrorKind as aW, type AthenaFindManyDebugAst as aX, type AthenaFindManyOptions as aY, type AthenaFindManyResult as aZ, type AthenaForgetPasswordRequest as a_, type AthenaAuthResetPasswordBinding as aa, type AthenaAuthResult as ab, type AthenaAuthRevokeSessionRequest as ac, type AthenaAuthSdkClient as ad, type AthenaAuthSearchOperator as ae, type AthenaAuthSession as af, type AthenaAuthSessionResponse as ag, type AthenaAuthSessionRevokeBinding as ah, type AthenaAuthSignInResponse as ai, type AthenaAuthSignOutResponse as aj, type AthenaAuthSocialRedirectResponse as ak, type AthenaAuthStatusResponse as al, type AthenaAuthUser as am, type AthenaChangeEmailRequest as an, type AthenaChangePasswordRequest as ao, AthenaClient as ap, type AthenaClientBuilder as aq, type AthenaClientContextOptions as ar, type AthenaClientExperimentalOptions as as, type AthenaClientFromEnvironmentOptions as at, type AthenaClientFromEnvironmentOptionsWithStorage as au, type AthenaClientFromEnvironmentOptionsWithStorageAndTypecheckedColumns as av, type AthenaClientFromEnvironmentOptionsWithTypecheckedColumns as aw, type AthenaClientOverrideOptions as ax, type AthenaClientSessionLike as ay, type AthenaClientSessionOptions as az, type AthenaAdminEmailFailureCreateRequest as b, type AthenaStorageTemplateVars as b$, type AthenaHeaderBag as b0, type AthenaInsertDebugAst as b1, type AthenaLinkSocialRequest as b2, type AthenaOAuthAccountTokenRequest as b3, type AthenaOAuthTokenBundle as b4, type AthenaOperationContext as b5, type AthenaOrderBy as b6, type AthenaQueryDebugAst as b7, type AthenaQueryTraceCallsite as b8, type AthenaQueryTraceEvent as b9, AthenaStorageError as bA, AthenaStorageErrorCode as bB, type AthenaStorageErrorDetails as bC, type AthenaStorageErrorHandler as bD, type AthenaStorageErrorInput as bE, type AthenaStorageFileConfig as bF, type AthenaStorageFileDeleteInput as bG, type AthenaStorageFileDownloadInput as bH, type AthenaStorageFileListInput as bI, type AthenaStorageFileModule as bJ, type AthenaStorageFileNamespace as bK, type AthenaStorageFileUploadInput as bL, type AthenaStorageFileUploadManyRequest as bM, type AthenaStorageFileUploadRequest as bN, type AthenaStorageFileUploadResult as bO, type AthenaStorageFolderNamespace as bP, type AthenaStorageManagedUpload as bQ, type AthenaStorageModule as bR, type AthenaStorageMultipartNamespace as bS, type AthenaStorageObjectFolderNamespace as bT, type AthenaStorageObjectNamespace as bU, type AthenaStoragePathContext as bV, type AthenaStoragePermissionNamespace as bW, type AthenaStoragePrefixPath as bX, type AthenaStoragePutBody as bY, type AthenaStoragePutOptions as bZ, type AthenaStorageTemplateValue as b_, type AthenaQueryTraceOptions as ba, type AthenaRawQueryDebugAst as bb, type AthenaRelationSelectNode as bc, type AthenaResetPasswordRequest as bd, type AthenaResult as be, type AthenaResultError as bf, type AthenaRpcBuilderStateAst as bg, type AthenaRpcDebugAst as bh, type AthenaSdkClient as bi, type AthenaSdkClientWithAuth as bj, type AthenaSdkClientWithStorage as bk, type AthenaSelectDebugAst as bl, type AthenaSelectDebugTransport as bm, type AthenaSelectShape as bn, type AthenaSendVerificationEmailRequest as bo, type AthenaSocialSignInRequest as bp, type AthenaStorageAuditNamespace as bq, type AthenaStorageBaseModule as br, type AthenaStorageBinaryCallOptions as bs, type AthenaStorageBucketCorsNamespace as bt, type AthenaStorageBucketNamespace as bu, type AthenaStorageCallOptions as bv, type AthenaStorageCatalogNamespace as bw, type AthenaStorageClientConfig as bx, type AthenaStorageCredentialsNamespace as by, type AthenaStorageEnv as bz, type AthenaAdminEmailFailureDeleteRequest as c, type StorageMultipartListPartsRequest as c$, type AthenaStorageUploadConstraints as c0, type AthenaStorageUploadProgress as c1, type AthenaStorageUploadProgressHandler as c2, type AthenaStorageUploadSource as c3, type AthenaStorageUploadedFile as c4, type AthenaTableBuilderStateAst as c5, type AthenaUnlinkAccountRequest as c6, type AthenaUpdateDebugAst as c7, type AthenaUpdateUserRequest as c8, type AthenaUpsertDebugAst as c9, type S3CredentialListItem as cA, type SearchStorageFilesRequest as cB, type SetManyStorageFileVisibilityRequest as cC, type SetStorageFileVisibilityRequest as cD, type StorageAuditEventRecord as cE, type StorageAuditListResponse as cF, type StorageAuditQueryRequest as cG, type StorageBatchUploadUrlResponse as cH, type StorageBatchUploadUrlResponseWithPut as cI, type StorageBucketCorsRequest as cJ, type StorageBucketCorsRuleInput as cK, type StorageBucketLifecycleRequest as cL, type StorageBucketLifecycleRuleInput as cM, type StorageBucketPolicyRequest as cN, type StorageFileAccessPurpose as cO, type StorageFileMutationManyResponse as cP, type StorageFileMutationResponse as cQ, type StorageFilePermissionRecord as cR, type StorageFileRetentionRequest as cS, type StorageFileVersionPathRequest as cT, type StorageFolderMutationResponse as cU, type StorageListFilesResponse as cV, type StorageListObjectsRequest as cW, type StorageMultipartAbortRequest as cX, type StorageMultipartCompletePartInput as cY, type StorageMultipartCompleteRequest as cZ, type StorageMultipartCreateRequest as c_, type AthenaUsernameSignInRequest as ca, type AthenaVerifyEmailRequest as cb, type AthenaWhere as cc, type AthenaWhereBooleanOperand as cd, type AthenaWhereOperatorInput as ce, type ConfirmStorageUploadRequest as cf, type CopyStorageFileRequest as cg, type CreateStorageCatalogRequest as ch, type CreateStorageUploadUrlRequest as ci, type CreateStorageUploadUrlsRequest as cj, type DeleteManyStorageFilesRequest as ck, type DeleteStorageFolderRequest as cl, type GetStorageFileUrlQuery as cm, type IntCoercionOptions as cn, type ListStorageFilesRequest as co, type ListStorageFoldersRequest as cp, type ManagedFileRecord as cq, type MoveStorageFolderRequest as cr, type NormalizedAthenaError as cs, type PresignedFileUrlResponse as ct, type RequireAffectedOptions as cu, type RetryBackoffStrategy as cv, type RetryConfig as cw, type RpcOrderOptions as cx, type RpcQueryBuilder as cy, type S3CatalogItem as cz, type AthenaAdminEmailFailureGetQuery as d, type StorageMultipartSignPartRequest as d0, type StorageObjectBaseRequest as d1, type StorageObjectCopyRequest as d2, type StorageObjectFolderCreateRequest as d3, type StorageObjectFolderDeleteRequest as d4, type StorageObjectFolderRenameRequest as d5, type StorageObjectPublicUrlRequest as d6, type StorageObjectRequest as d7, type StorageObjectValidateRequest as d8, type StorageObjectVersionListRequest as d9, assertInt as dA, coerceInt as dB, createAthenaStorageError as dC, createClient as dD, createStorageModule as dE, getAthenaDebugAst as dF, isOk as dG, normalizeAthenaError as dH, parseBooleanFlag as dI, requireAffected as dJ, requireSuccess as dK, storageSdkManifest as dL, unwrap as dM, unwrapOne as dN, unwrapRows as dO, verifyAthenaGatewayUrl as dP, withRetry as dQ, type AthenaAuthFetchCompatibleInput as dR, type StorageObjectVersionMutationRequest as da, type StoragePermissionCheckRequest as db, type StoragePermissionCheckResponse as dc, type StoragePermissionGrantRequest as dd, type StoragePermissionListRequest as de, type StoragePermissionListResponse as df, type StoragePermissionRevokeRequest as dg, type StoragePresignUploadRequest as dh, type StoragePublicAccessBlockRequest as di, type StorageServerSideEncryptionOptions as dj, type StorageSetBucketCorsRequest as dk, type StorageSetBucketLifecycleRequest as dl, type StorageSetBucketPolicyRequest as dm, type StorageSetPublicAccessBlockRequest as dn, type StorageSignedPostPolicyRequest as dp, type StorageUpdateObjectRequest as dq, type StorageUploadUrlResponse as dr, type StorageUploadUrlResponseWithPut as ds, type TableQueryBuilder as dt, type TreeStorageFoldersRequest as du, type UnwrapOneOptions as dv, type UnwrapOptions as dw, type UpdateManyStorageFilesRequest as dx, type UpdateStorageCatalogRequest as dy, type UpdateStorageFileRequest as dz, type AthenaAdminEmailFailureGetResponse as e, type AthenaAdminEmailFailureListQuery as f, type AthenaAdminEmailFailureListResponse as g, type AthenaAdminEmailFailureUpdateRequest as h, type AthenaAdminEmailFailureUpdateResponse as i, type AthenaAdminEmailGetQuery as j, type AthenaAdminEmailGetResponse as k, type AthenaAdminEmailListQuery as l, type AthenaAdminEmailListResponse as m, type AthenaAdminEmailTemplateCreateRequest as n, type AthenaAdminEmailTemplateDeleteRequest as o, type AthenaAdminEmailTemplateGetQuery as p, type AthenaAdminEmailTemplateGetResponse as q, type AthenaAdminEmailTemplateListQuery as r, type AthenaAdminEmailTemplateListResponse as s, type AthenaAdminEmailTemplateUpdateRequest as t, type AthenaAdminEmailUpdateRequest as u, type AthenaAdminEmailUpdateResponse as v, type AthenaAdminListUsersFilterOperator as w, type AthenaAdminListUsersQuery as x, type AthenaAdminListUsersSearchOperator as y, type AthenaAuthAdminUserSessionRevokeBinding as z };