@xylex-group/athena 2.8.2 → 2.10.0

package/dist/{model-form-Cx3wtvi8.d.ts → client-B7EQ_hPV.d.cts}

@@ -1,10 +1,10 @@
-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.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, $ 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';
 type AthenaAuthQueryPrimitive = string | number | boolean;
 type AthenaAuthQueryValue = AthenaAuthQueryPrimitive | AthenaAuthQueryPrimitive[] | null | undefined;
-type AthenaAuthEndpointPath = '/sign-in/social' | '/sign-in/email' | '/sign-in/username' | '/sign-up/email' | '/get-session' | '/sign-out' | '/forget-password' | '/reset-password' | '/verify-email' | '/send-verification-email' | '/change-email' | '/change-email/verify' | '/change-password' | '/set-password' | '/update-user' | '/delete-user' | '/delete-user/verify' | '/delete-user/callback' | '/email-list' | '/email/list' | '/list-sessions' | '/revoke-session' | '/revoke-sessions' | '/revoke-other-sessions' | '/link-social' | '/list-accounts' | '/unlink-account' | '/refresh-token' | '/get-access-token' | '/two-factor/get-totp-uri' | '/two-factor/verify-totp' | '/two-factor/send-otp' | '/two-factor/verify-otp' | '/two-factor/verify-backup-code' | '/two-factor/generate-backup-codes' | '/two-factor/enable' | '/two-factor/disable' | '/passkey/generate-register-options' | '/passkey/generate-authenticate-options' | '/passkey/verify-registration' | '/passkey/verify-authentication' | '/passkey/list-user-passkeys' | '/passkey/delete-passkey' | '/passkey/update-passkey' | '/.well-known/webauthn' | '/admin/set-role' | '/admin/list-users' | '/admin/list-user-sessions' | '/admin/create-user' | '/admin/unban-user' | '/admin/ban-user' | '/admin/impersonate-user' | '/admin/stop-impersonating' | '/admin/revoke-user-session' | '/admin/revoke-user-sessions' | '/admin/remove-user' | '/admin/set-user-password' | '/admin/has-permission' | '/admin/api-key/create' | '/admin/athena-client/create' | '/admin/athena-client/list' | '/admin/audit-log/list' | '/admin/email/get' | '/admin/email/create' | '/admin/email/update' | '/admin/email/delete' | '/admin/email-failure/list' | '/admin/email-failure/get' | '/admin/email-failure/create' | '/admin/email-failure/update' | '/admin/email-failure/delete' | '/admin/email-template/get' | '/admin/email-template/create' | '/admin/email-template/delete' | '/admin/email-template/list' | '/admin/email-template/update' | '/admin/email/list' | '/api-key/create' | '/api-key/get' | '/api-key/update' | '/api-key/delete' | '/api-key/list' | '/api-key/verify' | '/api-key/delete-all-expired-api-keys' | '/organization/create' | '/organization/check-slug' | '/organization/list' | '/organization/set-active' | '/organization/get-full-organization' | '/organization/update' | '/organization/delete' | '/organization/invite-member' | '/organization/accept-invitation' | '/organization/cancel-invitation' | '/organization/reject-invitation' | '/organization/get-invitation' | '/organization/list-invitations' | '/organization/list-user-invitations' | '/organization/list-members' | '/organization/remove-member' | '/organization/update-member-role' | '/organization/get-active-member' | '/organization/leave' | '/organization/has-permission' | `/callback/${string}` | '/health' | '/ok' | '/error' | `/reset-password/${string}`;
+type AthenaAuthEndpointPath = '/sign-in/social' | '/sign-in/email' | '/sign-in/username' | '/sign-up/email' | '/get-session' | '/sign-out' | '/forget-password' | '/reset-password' | '/verify-email' | '/send-verification-email' | '/change-email' | '/change-email/verify' | '/change-password' | '/set-password' | '/update-user' | '/delete-user' | '/delete-user/verify' | '/delete-user/callback' | '/email-list' | '/email/list' | '/list-sessions' | '/revoke-session' | '/revoke-sessions' | '/revoke-other-sessions' | '/link-social' | '/list-accounts' | '/unlink-account' | '/refresh-token' | '/get-access-token' | '/two-factor/get-totp-uri' | '/two-factor/verify-totp' | '/two-factor/send-otp' | '/two-factor/verify-otp' | '/two-factor/verify-backup-code' | '/two-factor/generate-backup-codes' | '/two-factor/enable' | '/two-factor/disable' | '/passkey/generate-register-options' | '/passkey/generate-authenticate-options' | '/passkey/verify-registration' | '/passkey/verify-authentication' | '/passkey/list-user-passkeys' | '/passkey/delete-passkey' | '/passkey/update-passkey' | '/.well-known/webauthn' | '/admin/set-role' | '/admin/list-users' | '/admin/list-user-sessions' | '/admin/create-user' | '/admin/unban-user' | '/admin/ban-user' | '/admin/impersonate-user' | '/admin/stop-impersonating' | '/admin/revoke-user-session' | '/admin/revoke-user-sessions' | '/admin/remove-user' | '/admin/set-user-password' | '/admin/has-permission' | '/admin/api-key/create' | '/admin/athena-client/create' | '/admin/athena-client/list' | '/admin/audit-log/list' | '/admin/email/get' | '/admin/email/create' | '/admin/email/update' | '/admin/email/delete' | '/admin/email-failure/list' | '/admin/email-failure/get' | '/admin/email-failure/create' | '/admin/email-failure/update' | '/admin/email-failure/delete' | '/admin/email-template/get' | '/admin/email-template/create' | '/admin/email-template/delete' | '/admin/email-template/list' | '/admin/email-template/update' | '/admin/email-template/send' | '/admin/email-event-type/list' | '/admin/email/list' | '/api-key/create' | '/api-key/get' | '/api-key/update' | '/api-key/delete' | '/api-key/list' | '/api-key/verify' | '/api-key/delete-all-expired-api-keys' | '/organization/create' | '/organization/check-slug' | '/organization/list' | '/organization/set-active' | '/organization/get-full-organization' | '/organization/update' | '/organization/delete' | '/organization/invite-member' | '/organization/accept-invitation' | '/organization/cancel-invitation' | '/organization/reject-invitation' | '/organization/get-invitation' | '/organization/list-invitations' | '/organization/list-user-invitations' | '/organization/list-members' | '/organization/remove-member' | '/organization/update-member-role' | '/organization/get-active-member' | '/organization/leave' | '/organization/has-permission' | `/callback/${string}` | '/health' | '/ok' | '/error' | `/reset-password/${string}`;
 type AthenaAuthErrorCode = 'NETWORK_ERROR' | 'HTTP_ERROR' | 'INVALID_JSON' | 'UNKNOWN_ERROR';
 interface AthenaAuthErrorDetails {
     code: AthenaAuthErrorCode;
@@ -56,6 +56,9 @@ interface AthenaAuthSessionResponse {
     session: AthenaAuthSession;
     user: AthenaAuthUser;
 }
+interface AthenaAuthGetUserResponse {
+    user: AthenaAuthUser | null;
+}
 interface AthenaAuthOrganization {
     id: string;
     name: string;
@@ -652,43 +655,77 @@ interface AthenaAdminEmailFailureDeleteRequest {
 interface AthenaAdminEmailTemplateListQuery {
     limit?: number;
     offset?: number;
-    templateKey?: string;
+    template_key?: string;
+    event_type?: string;
     locale?: string;
-    isActive?: boolean;
+    is_active?: boolean;
+}
+interface AthenaAuthEmailTemplateVariableBinding {
+    name: string;
+    source: string;
+    required?: boolean;
+}
+interface AthenaAuthEmailTemplateAttachment {
+    file_url: string;
+    filename?: string;
+}
+interface AthenaAdminEmailTemplateRecord {
+    id?: string;
+    template_key: string;
+    event_type?: string | null;
+    subject_template?: string | null;
+    text_template?: string | null;
+    html_template?: string | null;
+    variables?: string[];
+    variable_bindings?: AthenaAuthEmailTemplateVariableBinding[];
+    attachments?: AthenaAuthEmailTemplateAttachment[];
+    attachment_failure_mode?: 'fail' | 'skip' | null;
+    is_active?: boolean;
+    metadata?: AthenaAuthLooseRecord;
+    created_at?: string;
+    updated_at?: string;
 }
 interface AthenaAdminEmailTemplateListResponse {
     total?: number;
     limit?: number;
     offset?: number;
-    emailTemplates?: AthenaAuthLooseRecord[];
+    email_templates?: AthenaAdminEmailTemplateRecord[];
 }
 interface AthenaAdminEmailTemplateCreateRequest {
-    templateKey: string;
+    template_key: string;
+    event_type?: string;
     locale?: string;
-    subjectTemplate: string;
-    textTemplate?: string;
-    htmlTemplate?: string;
+    subject_template?: string;
+    text_template?: string;
+    html_template?: string;
     /**
-     * Optional React Email render input. When provided, `htmlTemplate` is derived automatically.
+     * Optional React Email render input. When provided, `html_template` is derived automatically.
      */
     react?: AthenaAuthReactEmailRenderInput;
     variables?: string[];
-    isActive?: boolean;
+    variable_bindings?: AthenaAuthEmailTemplateVariableBinding[];
+    attachments?: string | AthenaAuthEmailTemplateAttachment | AthenaAuthEmailTemplateAttachment[];
+    attachment_failure_mode?: 'fail' | 'skip';
+    is_active?: boolean;
     metadata?: AthenaAuthLooseRecord;
 }
 interface AthenaAdminEmailTemplateUpdateRequest {
     id: string;
-    templateKey?: string;
+    template_key?: string;
+    event_type?: string;
     locale?: string;
-    subjectTemplate?: string;
-    textTemplate?: string | null;
-    htmlTemplate?: string | null;
+    subject_template?: string;
+    text_template?: string | null;
+    html_template?: string | null;
     /**
-     * Optional React Email render input. When provided, `htmlTemplate` is derived automatically.
+     * Optional React Email render input. When provided, `html_template` is derived automatically.
      */
     react?: AthenaAuthReactEmailRenderInput;
     variables?: string[];
-    isActive?: boolean;
+    variable_bindings?: AthenaAuthEmailTemplateVariableBinding[];
+    attachments?: string | AthenaAuthEmailTemplateAttachment | AthenaAuthEmailTemplateAttachment[];
+    attachment_failure_mode?: 'fail' | 'skip';
+    is_active?: boolean;
     metadata?: AthenaAuthLooseRecord;
 }
 interface AthenaAdminEmailTemplateDeleteRequest {
@@ -698,7 +735,37 @@ interface AthenaAdminEmailTemplateGetQuery {
     id: string;
 }
 interface AthenaAdminEmailTemplateGetResponse {
-    emailTemplate?: AthenaAuthLooseRecord;
+    email_template?: AthenaAdminEmailTemplateRecord;
+}
+interface AthenaAdminEmailTemplateSendRequest {
+    template_id: string;
+    recipient_email: string;
+    render_variables?: AthenaAuthLooseRecord;
+    user_id?: string;
+    organization_id?: string;
+    session_token?: string;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailTemplateSendResponse {
+    success: boolean;
+    flow?: string | null;
+    template_id?: string | null;
+    template_key?: string | null;
+    event_type?: string | null;
+    recipient_email?: string | null;
+    subject?: string | null;
+    attachment_count?: number | null;
+    delivery_metadata?: AthenaAuthLooseRecord | null;
+    email_send_failure_id?: string | null;
+    error?: string | null;
+}
+interface AthenaAdminEmailEventTypeRecord {
+    event_type: string;
+    label?: string | null;
+    description?: string | null;
+}
+interface AthenaAdminEmailEventTypeListResponse {
+    event_types?: AthenaAdminEmailEventTypeRecord[];
 }
 interface AthenaApiKeyCreateRequest {
     name?: string;
@@ -858,6 +925,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 +939,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 +1027,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 +1063,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 +1212,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>>;
@@ -1179,11 +1271,17 @@ interface AthenaAuthBindings {
                     query: AthenaAdminEmailTemplateGetQuery;
                 } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateGetResponse>>;
                 /** Create email template. Route: `POST /admin/email-template/create`. */
-                create: (input: AthenaAdminEmailTemplateCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLooseRecord>>;
+                create: (input: AthenaAdminEmailTemplateCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateRecord>>;
                 /** Update email template. Route: `POST /admin/email-template/update`. */
-                update: (input: AthenaAdminEmailTemplateUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLooseRecord>>;
+                update: (input: AthenaAdminEmailTemplateUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateRecord>>;
                 /** Delete email template. Route: `POST /admin/email-template/delete`. */
                 delete: (input: AthenaAdminEmailTemplateDeleteRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+                /** Send one stored email template. Route: `POST /admin/email-template/send`. */
+                send: (input: AthenaAdminEmailTemplateSendRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateSendResponse>>;
+            };
+            eventType: {
+                /** List canonical admin email event types. Route: `GET /admin/email-event-type/list`. */
+                list: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailEventTypeListResponse>>;
             };
         };
         emailTemplate: {
@@ -1192,7 +1290,7 @@ interface AthenaAuthBindings {
                 query: AthenaAdminEmailTemplateGetQuery;
             } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateGetResponse>>;
             /** Create email template. Route: `POST /admin/email-template/create`. */
-            create: (input: AthenaAdminEmailTemplateCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLooseRecord>>;
+            create: (input: AthenaAdminEmailTemplateCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateRecord>>;
             /** Delete email template. Route: `POST /admin/email-template/delete`. */
             delete: (input: AthenaAdminEmailTemplateDeleteRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
             /** List email templates. Route: `GET /admin/email-template/list`. */
@@ -1200,7 +1298,13 @@ interface AthenaAuthBindings {
                 query?: AthenaAdminEmailTemplateListQuery;
             } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateListResponse>>;
             /** Update email template. Route: `POST /admin/email-template/update`. */
-            update: (input: AthenaAdminEmailTemplateUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLooseRecord>>;
+            update: (input: AthenaAdminEmailTemplateUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateRecord>>;
+            /** Send one stored email template. Route: `POST /admin/email-template/send`. */
+            send: (input: AthenaAdminEmailTemplateSendRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateSendResponse>>;
+        };
+        emailEventType: {
+            /** List canonical admin email event types. Route: `GET /admin/email-event-type/list`. */
+            list: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailEventTypeListResponse>>;
         };
     };
     apiKey: {
@@ -1254,6 +1358,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 +1569,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.
@@ -2935,6 +3045,380 @@ interface AthenaStorageModule extends AthenaStorageBaseModule {
 declare function createAthenaStorageError(input: AthenaStorageErrorInput): AthenaStorageError;
 declare function createStorageModule(gateway: AthenaGatewayClient, runtimeOptions?: AthenaStorageClientConfig): AthenaStorageModule;
 
+type AthenaChatRoomKind = 'dm' | 'group' | 'channel';
+type AthenaChatMemberRole = 'owner' | 'admin' | 'member';
+interface AthenaChatAttachmentInput {
+    file_id: string;
+    ordinal: number;
+}
+interface AthenaChatAttachmentView extends AthenaChatAttachmentInput {
+    file_name?: string | null;
+    original_name?: string | null;
+    content_type?: string | null;
+    mime_type?: string | null;
+    extension?: string | null;
+    size_bytes?: number | null;
+    status?: string | null;
+    visibility?: string | null;
+    file_url?: string | null;
+    bucket?: string | null;
+    storage_key?: string | null;
+    authorized_url_path: string;
+    proxy_url_path: string;
+    public_url_path: string;
+}
+interface AthenaChatReactionCount {
+    emoji: string;
+    count: number;
+    reacted: boolean;
+}
+interface AthenaChatReactionSummary {
+    message_id: string;
+    reactions: AthenaChatReactionCount[];
+}
+interface AthenaChatMessage {
+    id: string;
+    room_id: string;
+    room_seq: number;
+    sender_id: string;
+    client_message_id?: string | null;
+    body_text?: string | null;
+    body_json?: Record<string, unknown> | null;
+    reply_to_message_id?: string | null;
+    created_at: string;
+    edited_at?: string | null;
+    deleted_at?: string | null;
+    metadata_json?: Record<string, unknown> | null;
+    attachments: AthenaChatAttachmentView[];
+    reactions: AthenaChatReactionCount[];
+}
+interface AthenaChatMessagePage {
+    items: AthenaChatMessage[];
+    next_before_seq?: number | null;
+}
+interface AthenaChatRoom {
+    id: string;
+    organization_id: string;
+    kind: AthenaChatRoomKind;
+    title?: string | null;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+    archived_at?: string | null;
+    last_message_id?: string | null;
+    last_message_seq: number;
+    last_message_at?: string | null;
+    version: number;
+}
+interface AthenaChatRoomPage {
+    items: AthenaChatRoom[];
+}
+interface AthenaChatMember {
+    room_id: string;
+    user_id: string;
+    role: AthenaChatMemberRole;
+    joined_at: string;
+    last_read_seq: number;
+    last_read_message_id?: string | null;
+    muted: boolean;
+    notification_mode?: string | null;
+    hidden_at?: string | null;
+}
+interface AthenaChatReadCursor {
+    room_id: string;
+    user_id: string;
+    last_read_seq: number;
+    last_read_message_id?: string | null;
+}
+interface AthenaChatDeleteResult {
+    ok: boolean;
+    message_id: string;
+}
+interface AthenaChatRemoveResult {
+    ok: boolean;
+    user_id: string;
+}
+interface AthenaChatSearchHit {
+    room_id: string;
+    message: AthenaChatMessage;
+}
+interface AthenaChatSearchPage {
+    items: AthenaChatSearchHit[];
+}
+interface AthenaChatCreateRoomRequest {
+    kind: AthenaChatRoomKind;
+    title?: string | null;
+    member_user_ids?: string[];
+}
+interface AthenaChatUpdateRoomRequest {
+    title?: string | null;
+}
+interface AthenaChatSendMessageRequest {
+    client_message_id?: string | null;
+    body_text?: string | null;
+    body_json?: Record<string, unknown> | null;
+    reply_to_message_id?: string | null;
+    metadata_json?: Record<string, unknown> | null;
+    attachments?: AthenaChatAttachmentInput[];
+}
+interface AthenaChatEditMessageRequest {
+    body_text?: string | null;
+    body_json?: Record<string, unknown> | null;
+    metadata_json?: Record<string, unknown> | null;
+}
+interface AthenaChatMarkReadUpToRequest {
+    message_id?: string | null;
+    seq?: number | null;
+}
+interface AthenaChatAddMembersRequest {
+    user_ids: string[];
+    role?: AthenaChatMemberRole | null;
+}
+interface AthenaChatAddReactionRequest {
+    emoji: string;
+}
+interface AthenaChatSearchMessagesRequest {
+    query: string;
+    room_id?: string | null;
+    limit?: number | null;
+}
+interface AthenaChatRoomCreatedResponse {
+    status: 'success';
+    message: string;
+    data: AthenaChatRoom;
+}
+interface AthenaChatMessageCreatedResponse {
+    status: 'success';
+    message: string;
+    data: AthenaChatMessage;
+}
+interface AthenaChatListRoomsQuery {
+    limit?: number;
+    offset?: number;
+    include_archived?: boolean;
+}
+interface AthenaChatListMessagesQuery {
+    limit?: number;
+    before_seq?: number;
+    after_seq?: number;
+}
+interface AthenaChatRealtimeInfoResponse {
+    status?: string;
+    message?: string;
+    data?: {
+        transport?: string;
+        path?: string;
+        api_base?: string;
+        actions?: string[];
+    };
+}
+interface AthenaChatResumeRoomCursor {
+    room_id: string;
+    last_seq: number;
+}
+interface AthenaChatPresenceUser {
+    user_id: string;
+    state: string;
+    active_room_id?: string | null;
+    at?: string | null;
+}
+interface AthenaChatWsAuthHelloCommand {
+    type: 'auth.hello';
+    token?: string | null;
+    room_subscriptions?: string[] | null;
+}
+interface AthenaChatWsSubscribeCommand {
+    type: 'chat.subscribe';
+    room_id: string;
+    from_seq?: number | null;
+}
+interface AthenaChatWsUnsubscribeCommand {
+    type: 'chat.unsubscribe';
+    room_id: string;
+}
+interface AthenaChatWsResumeCommand {
+    type: 'chat.resume';
+    rooms: AthenaChatResumeRoomCursor[];
+}
+interface AthenaChatWsTypingStartCommand {
+    type: 'chat.typing.start';
+    room_id: string;
+}
+interface AthenaChatWsTypingStopCommand {
+    type: 'chat.typing.stop';
+    room_id: string;
+}
+interface AthenaChatWsPresenceHeartbeatCommand {
+    type: 'chat.presence.heartbeat';
+    active_room_id?: string | null;
+}
+interface AthenaChatWsReadUpToCommand {
+    type: 'chat.read.up_to';
+    room_id: string;
+    message_id?: string | null;
+    seq?: number | null;
+}
+interface AthenaChatWsPingCommand {
+    type: 'ping';
+    at: string;
+}
+type AthenaChatWsClientCommand = AthenaChatWsAuthHelloCommand | AthenaChatWsSubscribeCommand | AthenaChatWsUnsubscribeCommand | AthenaChatWsResumeCommand | AthenaChatWsTypingStartCommand | AthenaChatWsTypingStopCommand | AthenaChatWsPresenceHeartbeatCommand | AthenaChatWsReadUpToCommand | AthenaChatWsPingCommand;
+interface AthenaChatWsHelloOkEvent {
+    type: 'hello.ok';
+    connection_id: string;
+    server_time: string;
+}
+interface AthenaChatWsSubscribedEvent {
+    type: 'chat.subscribed';
+    room_id: string;
+    from_seq?: number | null;
+}
+interface AthenaChatWsRoomEventBase {
+    room_id: string;
+    room: AthenaChatRoom;
+}
+interface AthenaChatWsRoomCreatedEvent extends AthenaChatWsRoomEventBase {
+    type: 'chat.room.created';
+}
+interface AthenaChatWsRoomUpdatedEvent extends AthenaChatWsRoomEventBase {
+    type: 'chat.room.updated';
+}
+interface AthenaChatWsRoomArchivedEvent extends AthenaChatWsRoomEventBase {
+    type: 'chat.room.archived';
+}
+interface AthenaChatWsMessageEventBase {
+    room_id: string;
+    message: AthenaChatMessage;
+}
+interface AthenaChatWsMessageCreatedEvent extends AthenaChatWsMessageEventBase {
+    type: 'chat.message.created';
+}
+interface AthenaChatWsMessageUpdatedEvent extends AthenaChatWsMessageEventBase {
+    type: 'chat.message.updated';
+}
+interface AthenaChatWsMessageDeletedEvent {
+    type: 'chat.message.deleted';
+    room_id: string;
+    message_id: string;
+    room_seq: number;
+}
+interface AthenaChatWsReadUpdatedEvent {
+    type: 'chat.read.updated';
+    room_id: string;
+    read_cursor: AthenaChatReadCursor;
+}
+interface AthenaChatWsMembersUpdatedEvent {
+    type: 'chat.members.updated';
+    room_id: string;
+    members: AthenaChatMember[];
+}
+interface AthenaChatWsTypingUpdatedEvent {
+    type: 'chat.typing.updated';
+    room_id: string;
+    user_ids: string[];
+}
+interface AthenaChatWsPresenceUpdatedEvent {
+    type: 'chat.presence.updated';
+    room_id?: string | null;
+    users: AthenaChatPresenceUser[];
+}
+interface AthenaChatWsSyncRequiredEvent {
+    type: 'chat.sync.required';
+    room_id?: string | null;
+    reason?: string | null;
+}
+interface AthenaChatWsReactionUpdatedEvent {
+    type: 'chat.reaction.updated';
+    room_id: string;
+    summary: AthenaChatReactionSummary;
+}
+interface AthenaChatWsPongEvent {
+    type: 'pong';
+    at: string;
+}
+interface AthenaChatWsErrorEvent {
+    type: 'error';
+    error: string;
+    code?: string | null;
+}
+type AthenaChatWsServerEvent = AthenaChatWsHelloOkEvent | AthenaChatWsSubscribedEvent | AthenaChatWsRoomCreatedEvent | AthenaChatWsRoomUpdatedEvent | AthenaChatWsRoomArchivedEvent | AthenaChatWsMessageCreatedEvent | AthenaChatWsMessageUpdatedEvent | AthenaChatWsMessageDeletedEvent | AthenaChatWsReadUpdatedEvent | AthenaChatWsMembersUpdatedEvent | AthenaChatWsTypingUpdatedEvent | AthenaChatWsPresenceUpdatedEvent | AthenaChatWsSyncRequiredEvent | AthenaChatWsReactionUpdatedEvent | AthenaChatWsPongEvent | AthenaChatWsErrorEvent;
+interface AthenaChatCallOptions {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    client?: string;
+    bearerToken?: string | null;
+    cookie?: string | null;
+    sessionToken?: string | null;
+    forceNoCache?: boolean;
+}
+interface AthenaChatWebSocketLike {
+    close(code?: number, reason?: string): void;
+    send(data: string): void;
+    addEventListener?(type: 'open' | 'message' | 'error' | 'close', listener: (event: unknown) => void): void;
+    removeEventListener?(type: 'open' | 'message' | 'error' | 'close', listener: (event: unknown) => void): void;
+    onopen?: ((event: unknown) => void) | null;
+    onmessage?: ((event: {
+        data?: string | ArrayBuffer | Uint8Array | Blob;
+    }) => void) | null;
+    onerror?: ((event: unknown) => void) | null;
+    onclose?: ((event: unknown) => void) | null;
+}
+type AthenaChatWebSocketFactory = ((url: string, protocols?: string | string[]) => AthenaChatWebSocketLike) | (new (url: string, protocols?: string | string[]) => AthenaChatWebSocketLike);
+interface AthenaChatConnectOptions {
+    protocols?: string | string[];
+    hello?: AthenaChatWsAuthHelloCommand;
+    onMessage?: (message: AthenaChatWsServerEvent | Record<string, unknown>) => void;
+}
+interface AthenaChatRealtimeConnection {
+    readonly socket: AthenaChatWebSocketLike;
+    send(command: AthenaChatWsClientCommand): void;
+    hello(command?: Omit<AthenaChatWsAuthHelloCommand, 'type'>): void;
+    subscribe(roomId: string, fromSeq?: number | null): void;
+    unsubscribe(roomId: string): void;
+    resume(rooms: AthenaChatResumeRoomCursor[]): void;
+    typingStart(roomId: string): void;
+    typingStop(roomId: string): void;
+    presenceHeartbeat(activeRoomId?: string | null): void;
+    readUpTo(roomId: string, input?: Omit<AthenaChatMarkReadUpToRequest, never>): void;
+    ping(at?: string): void;
+    close(code?: number, reason?: string): void;
+}
+interface AthenaChatRealtimeModule {
+    info(options?: AthenaChatCallOptions): Promise<AthenaChatRealtimeInfoResponse>;
+    connect(options?: AthenaChatConnectOptions): AthenaChatRealtimeConnection;
+}
+interface AthenaChatModule {
+    room: {
+        list(query?: AthenaChatListRoomsQuery, options?: AthenaChatCallOptions): Promise<AthenaChatRoomPage>;
+        create(input: AthenaChatCreateRoomRequest, options?: AthenaChatCallOptions): Promise<AthenaChatRoomCreatedResponse>;
+        get(roomId: string, options?: AthenaChatCallOptions): Promise<AthenaChatRoom>;
+        update(roomId: string, input: AthenaChatUpdateRoomRequest, options?: AthenaChatCallOptions): Promise<AthenaChatRoom>;
+        archive(roomId: string, options?: AthenaChatCallOptions): Promise<AthenaChatRoom>;
+        readCursor: {
+            upTo(roomId: string, input?: AthenaChatMarkReadUpToRequest, options?: AthenaChatCallOptions): Promise<AthenaChatReadCursor>;
+        };
+        member: {
+            list(roomId: string, options?: AthenaChatCallOptions): Promise<AthenaChatMember[]>;
+            add(roomId: string, input: AthenaChatAddMembersRequest, options?: AthenaChatCallOptions): Promise<AthenaChatMember[]>;
+            remove(roomId: string, userId: string, options?: AthenaChatCallOptions): Promise<AthenaChatRemoveResult>;
+        };
+        message: {
+            list(roomId: string, query?: AthenaChatListMessagesQuery, options?: AthenaChatCallOptions): Promise<AthenaChatMessagePage>;
+            send(roomId: string, input: AthenaChatSendMessageRequest, options?: AthenaChatCallOptions): Promise<AthenaChatMessageCreatedResponse>;
+            update(roomId: string, messageId: string, input: AthenaChatEditMessageRequest, options?: AthenaChatCallOptions): Promise<AthenaChatMessage>;
+            delete(roomId: string, messageId: string, options?: AthenaChatCallOptions): Promise<AthenaChatDeleteResult>;
+        };
+    };
+    message: {
+        reaction: {
+            add(messageId: string, input: AthenaChatAddReactionRequest, options?: AthenaChatCallOptions): Promise<AthenaChatReactionSummary>;
+            remove(messageId: string, emoji: string, options?: AthenaChatCallOptions): Promise<AthenaChatReactionSummary>;
+        };
+        search(input: AthenaChatSearchMessagesRequest, options?: AthenaChatCallOptions): Promise<AthenaChatSearchPage>;
+    };
+    realtime: AthenaChatRealtimeModule;
+}
+
 type AthenaRowShape$1 = Record<string, AthenaJsonValue | undefined>;
 type FilterColumnKey$1<Row> = Extract<keyof NonNullable<Row>, string>;
 type ResolvedFilterColumnKey$1<Row> = [FilterColumnKey$1<Row>] extends [never] ? string : FilterColumnKey$1<Row>;
@@ -3240,6 +3724,31 @@ interface AthenaResultError {
     cause?: string;
     raw: unknown;
 }
+type AthenaRequestService = 'db' | 'auth' | 'chat' | 'storage';
+type AthenaRequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+interface AthenaRequestQueryValueMap {
+    [key: string]: string | number | boolean | null | undefined | Array<string | number | boolean | null | undefined>;
+}
+interface AthenaRequestOptions {
+    service?: AthenaRequestService;
+    url?: string;
+    path?: string;
+    method?: AthenaRequestMethod;
+    headers?: Record<string, string>;
+    query?: AthenaRequestQueryValueMap;
+    body?: RequestInit['body'] | Record<string, unknown> | unknown[] | null;
+    signal?: AbortSignal;
+    credentials?: RequestInit['credentials'];
+    responseType?: 'json' | 'text' | 'response';
+}
+interface AthenaRequestResponse<T = unknown> {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    data: T | string | null;
+    raw: Response;
+}
 interface AthenaClientExperimentalOptions {
     /**
      * @deprecated Failed `AthenaResult` values now include normalized structured `error`
@@ -3433,34 +3942,68 @@ interface AthenaSdkClient<TStrict extends boolean = false> {
     db: AthenaDbModule<TStrict>;
     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[]>>;
+    request<T = unknown>(options: AthenaRequestOptions): Promise<AthenaRequestResponse<T>>;
     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;
+    chat: AthenaChatModule;
+    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 | undefined;
 }
-interface AthenaCreateClientAuthOptions extends Omit<AthenaAuthClientConfig, 'baseUrl' | 'apiKey' | 'bearerToken'> {
+interface AthenaCreateClientChatOptions extends AthenaCreateClientServiceUrlConfig {
+    wsUrl?: string | null | undefined;
+    webSocketFactory?: AthenaChatWebSocketFactory | 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;
+    chat?: AthenaCreateClientChatOptions;
     storage?: AthenaCreateClientServiceUrlConfig;
     dbUrl?: string | null | undefined;
     gatewayUrl?: string | null | undefined;
     authUrl?: string | null | undefined;
+    chatUrl?: string | null | undefined;
+    chatWsUrl?: string | null | undefined;
     storageUrl?: string | null | undefined;
     experimental?: AthenaClientExperimentalOptions;
 }
@@ -3496,6 +4039,41 @@ interface AthenaCreateClientConfigWithStorageAndTypecheckedColumns extends Athen
     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 | null | undefined): AthenaClientBuilder<StorageEnabled, TStrict>;
@@ -3534,7 +4112,10 @@ 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>;
@@ -3546,97 +4127,4 @@ declare function createClient(url: string | null | undefined, apiKey: string | n
 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;
-    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>;
-
-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 };
+export { type AthenaAuthGuardResult as $, type AthenaAdminEmailCreateRequest as A, type AthenaAdminEmailUpdateResponse as B, type AthenaAdminListUsersFilterOperator as C, type AthenaAdminListUsersQuery as D, type AthenaAdminListUsersSearchOperator as E, type AthenaAuthAdminUserSessionRevokeBinding as F, type AthenaAuthBindings as G, type AthenaAuthCallOptions as H, type AthenaAuthClientConfig as I, type AthenaAuthCredentials as J, type AthenaAuthEmailChangeResponse as K, type AthenaAuthEmailTemplateAttachment as L, type AthenaAuthEmailTemplateBuilder as M, type AthenaAuthEmailTemplateCreateFromDefinitionInput as N, type AthenaAuthEmailTemplateDefinition as O, type AthenaAuthEmailTemplateReactOverrides as P, type AthenaAuthEmailTemplateUpdateFromDefinitionInput as Q, type AthenaAuthEmailTemplateVariableBinding as R, type AthenaAuthEndpointPath as S, type AthenaAuthErrorCode as T, type AthenaAuthErrorDetails as U, type AthenaAuthFilterOperator as V, type AthenaAuthGenericInput as W, type AthenaAuthGenericQueryInput as X, type AthenaAuthGetUserResponse as Y, type AthenaAuthGuardFailure as Z, type AthenaAuthGuardReason as _, type AthenaAdminEmailDeleteRequest as a, type AthenaChatSearchHit as a$, type AthenaAuthGuardSuccess as a0, type AthenaAuthLinkedAccount as a1, type AthenaAuthMethod as a2, type AthenaAuthOrganization as a3, type AthenaAuthOrganizationBindings as a4, type AthenaAuthOrganizationInvitation as a5, type AthenaAuthOrganizationMember as a6, type AthenaAuthQueryPrimitive as a7, type AthenaAuthQueryValue as a8, type AthenaAuthReactEmailComponent as a9, type AthenaChatCallOptions as aA, type AthenaChatConnectOptions as aB, type AthenaChatCreateRoomRequest as aC, type AthenaChatDeleteResult as aD, type AthenaChatEditMessageRequest as aE, type AthenaChatListMessagesQuery as aF, type AthenaChatListRoomsQuery as aG, type AthenaChatMarkReadUpToRequest as aH, type AthenaChatMember as aI, type AthenaChatMemberRole as aJ, type AthenaChatMessage as aK, type AthenaChatMessageCreatedResponse as aL, type AthenaChatMessagePage as aM, type AthenaChatModule as aN, type AthenaChatPresenceUser as aO, type AthenaChatReactionCount as aP, type AthenaChatReactionSummary as aQ, type AthenaChatReadCursor as aR, type AthenaChatRealtimeConnection as aS, type AthenaChatRealtimeInfoResponse as aT, type AthenaChatRealtimeModule as aU, type AthenaChatRemoveResult as aV, type AthenaChatResumeRoomCursor as aW, type AthenaChatRoom as aX, type AthenaChatRoomCreatedResponse as aY, type AthenaChatRoomKind as aZ, type AthenaChatRoomPage as a_, type AthenaAuthReactEmailConfig as aa, type AthenaAuthReactEmailEventPhase as ab, type AthenaAuthReactEmailProps as ac, type AthenaAuthReactEmailRenderEvent as ad, type AthenaAuthReactEmailRenderInput as ae, type AthenaAuthReactEmailRenderOptions as af, type AthenaAuthRequestInput as ag, type AthenaAuthResetPasswordBinding as ah, type AthenaAuthResult as ai, type AthenaAuthRevokeSessionRequest as aj, type AthenaAuthSdkClient as ak, type AthenaAuthSearchOperator as al, type AthenaAuthSession as am, type AthenaAuthSessionResponse as an, type AthenaAuthSessionRevokeBinding as ao, type AthenaAuthSignInResponse as ap, type AthenaAuthSignOutResponse as aq, type AthenaAuthSocialRedirectResponse as ar, type AthenaAuthStatusResponse as as, type AthenaAuthUser as at, type AthenaChangeEmailRequest as au, type AthenaChangePasswordRequest as av, type AthenaChatAddMembersRequest as aw, type AthenaChatAddReactionRequest as ax, type AthenaChatAttachmentInput as ay, type AthenaChatAttachmentView as az, type AthenaAdminEmailEventTypeListResponse as b, type AthenaEmailSignUpRequest as b$, type AthenaChatSearchMessagesRequest as b0, type AthenaChatSearchPage as b1, type AthenaChatSendMessageRequest as b2, type AthenaChatUpdateRoomRequest as b3, type AthenaChatWebSocketFactory as b4, type AthenaChatWebSocketLike as b5, type AthenaChatWsAuthHelloCommand as b6, type AthenaChatWsClientCommand as b7, type AthenaChatWsErrorEvent as b8, type AthenaChatWsHelloOkEvent as b9, type AthenaClientBuilder as bA, type AthenaClientContextOptions as bB, type AthenaClientExperimentalOptions as bC, type AthenaClientFromEnvironmentOptions as bD, type AthenaClientFromEnvironmentOptionsWithStorage as bE, type AthenaClientFromEnvironmentOptionsWithStorageAndTypecheckedColumns as bF, type AthenaClientFromEnvironmentOptionsWithTypecheckedColumns as bG, type AthenaClientOverrideOptions as bH, type AthenaClientSessionLike as bI, type AthenaClientSessionOptions as bJ, type AthenaCreateClientAuthOptions as bK, type AthenaCreateClientChatOptions as bL, type AthenaCreateClientConfig as bM, type AthenaCreateClientConfigWithStorage as bN, type AthenaCreateClientConfigWithStorageAndTypecheckedColumns as bO, type AthenaCreateClientConfigWithTypecheckedColumns as bP, type AthenaCreateClientOptions as bQ, type AthenaCreateClientOptionsWithStorage as bR, type AthenaCreateClientOptionsWithStorageAndTypecheckedColumns as bS, type AthenaCreateClientOptionsWithTypecheckedColumns as bT, type AthenaCreateClientServiceUrlConfig as bU, type AthenaDbModule as bV, type AthenaDeleteDebugAst as bW, type AthenaDeleteUserCallbackRequest as bX, type AthenaDeleteUserRequest as bY, type AthenaDeleteUserResponse as bZ, type AthenaEmailSignInRequest as b_, type AthenaChatWsMembersUpdatedEvent as ba, type AthenaChatWsMessageCreatedEvent as bb, type AthenaChatWsMessageDeletedEvent as bc, type AthenaChatWsMessageEventBase as bd, type AthenaChatWsMessageUpdatedEvent as be, type AthenaChatWsPingCommand as bf, type AthenaChatWsPongEvent as bg, type AthenaChatWsPresenceHeartbeatCommand as bh, type AthenaChatWsPresenceUpdatedEvent as bi, type AthenaChatWsReactionUpdatedEvent as bj, type AthenaChatWsReadUpToCommand as bk, type AthenaChatWsReadUpdatedEvent as bl, type AthenaChatWsResumeCommand as bm, type AthenaChatWsRoomArchivedEvent as bn, type AthenaChatWsRoomCreatedEvent as bo, type AthenaChatWsRoomEventBase as bp, type AthenaChatWsRoomUpdatedEvent as bq, type AthenaChatWsServerEvent as br, type AthenaChatWsSubscribeCommand as bs, type AthenaChatWsSubscribedEvent as bt, type AthenaChatWsSyncRequiredEvent as bu, type AthenaChatWsTypingStartCommand as bv, type AthenaChatWsTypingStopCommand as bw, type AthenaChatWsTypingUpdatedEvent as bx, type AthenaChatWsUnsubscribeCommand as by, AthenaClient as bz, type AthenaAdminEmailEventTypeRecord as c, type AthenaStorageFileUploadInput as c$, type AthenaEnvelope as c0, AthenaError as c1, AthenaErrorCategory as c2, AthenaErrorCode as c3, type AthenaErrorInput as c4, AthenaErrorKind as c5, type AthenaFindManyDebugAst as c6, type AthenaFindManyOptions as c7, type AthenaFindManyResult as c8, type AthenaForgetPasswordRequest as c9, type AthenaSdkClientWithStorage as cA, type AthenaSelectDebugAst as cB, type AthenaSelectDebugTransport as cC, type AthenaSelectShape as cD, type AthenaSendVerificationEmailRequest as cE, type AthenaSocialSignInRequest as cF, type AthenaStorageAuditNamespace as cG, type AthenaStorageBaseModule as cH, type AthenaStorageBinaryCallOptions as cI, type AthenaStorageBucketCorsNamespace as cJ, type AthenaStorageBucketNamespace as cK, type AthenaStorageCallOptions as cL, type AthenaStorageCatalogNamespace as cM, type AthenaStorageClientConfig as cN, type AthenaStorageCredentialsNamespace as cO, type AthenaStorageEnv as cP, AthenaStorageError as cQ, AthenaStorageErrorCode as cR, type AthenaStorageErrorDetails as cS, type AthenaStorageErrorHandler as cT, type AthenaStorageErrorInput as cU, type AthenaStorageFileConfig as cV, type AthenaStorageFileDeleteInput as cW, type AthenaStorageFileDownloadInput as cX, type AthenaStorageFileListInput as cY, type AthenaStorageFileModule as cZ, type AthenaStorageFileNamespace as c_, type AthenaFromOptions as ca, type AthenaHeaderBag as cb, type AthenaInsertDebugAst as cc, type AthenaLinkSocialRequest as cd, type AthenaOAuthAccountTokenRequest as ce, type AthenaOAuthTokenBundle as cf, type AthenaOperationContext as cg, type AthenaOrderBy as ch, type AthenaQueryDebugAst as ci, type AthenaQueryTraceCallsite as cj, type AthenaQueryTraceEvent as ck, type AthenaQueryTraceOptions as cl, type AthenaRawQueryDebugAst as cm, type AthenaRelationSelectNode as cn, type AthenaRequestMethod as co, type AthenaRequestOptions as cp, type AthenaRequestQueryValueMap as cq, type AthenaRequestResponse as cr, type AthenaRequestService as cs, type AthenaResetPasswordRequest as ct, type AthenaResult as cu, type AthenaResultError as cv, type AthenaRpcBuilderStateAst as cw, type AthenaRpcDebugAst as cx, type AthenaSdkClient as cy, type AthenaSdkClientWithAuth as cz, type AthenaAdminEmailFailureCreateRequest as d, type StorageBucketCorsRuleInput as d$, type AthenaStorageFileUploadManyRequest as d0, type AthenaStorageFileUploadRequest as d1, type AthenaStorageFileUploadResult as d2, type AthenaStorageFolderNamespace as d3, type AthenaStorageManagedUpload as d4, type AthenaStorageModule as d5, type AthenaStorageMultipartNamespace as d6, type AthenaStorageObjectFolderNamespace as d7, type AthenaStorageObjectNamespace as d8, type AthenaStoragePathContext as d9, type CreateStorageUploadUrlsRequest as dA, type DeleteManyStorageFilesRequest as dB, type DeleteStorageFolderRequest as dC, type GetStorageFileUrlQuery as dD, type IntCoercionOptions as dE, type ListStorageFilesRequest as dF, type ListStorageFoldersRequest as dG, type ManagedFileRecord as dH, type MoveStorageFolderRequest as dI, type NormalizedAthenaError as dJ, type PresignedFileUrlResponse as dK, type RequireAffectedOptions as dL, type RetryBackoffStrategy as dM, type RetryConfig as dN, type RpcOrderOptions as dO, type RpcQueryBuilder as dP, type S3CatalogItem as dQ, type S3CredentialListItem as dR, type SearchStorageFilesRequest as dS, type SetManyStorageFileVisibilityRequest as dT, type SetStorageFileVisibilityRequest as dU, type StorageAuditEventRecord as dV, type StorageAuditListResponse as dW, type StorageAuditQueryRequest as dX, type StorageBatchUploadUrlResponse as dY, type StorageBatchUploadUrlResponseWithPut as dZ, type StorageBucketCorsRequest as d_, type AthenaStoragePermissionNamespace as da, type AthenaStoragePrefixPath as db, type AthenaStoragePutBody as dc, type AthenaStoragePutOptions as dd, type AthenaStorageTemplateValue as de, type AthenaStorageTemplateVars as df, type AthenaStorageUploadConstraints as dg, type AthenaStorageUploadProgress as dh, type AthenaStorageUploadProgressHandler as di, type AthenaStorageUploadSource as dj, type AthenaStorageUploadedFile as dk, type AthenaTableBuilderStateAst as dl, type AthenaUnlinkAccountRequest as dm, type AthenaUpdateDebugAst as dn, type AthenaUpdateUserRequest as dp, type AthenaUpsertDebugAst as dq, type AthenaUsernameSignInRequest as dr, type AthenaVerifyEmailRequest as ds, type AthenaWhere as dt, type AthenaWhereBooleanOperand as du, type AthenaWhereOperatorInput as dv, type ConfirmStorageUploadRequest as dw, type CopyStorageFileRequest as dx, type CreateStorageCatalogRequest as dy, type CreateStorageUploadUrlRequest as dz, type AthenaAdminEmailFailureDeleteRequest as e, storageSdkManifest as e$, type StorageBucketLifecycleRequest as e0, type StorageBucketLifecycleRuleInput as e1, type StorageBucketPolicyRequest as e2, type StorageFileAccessPurpose as e3, type StorageFileMutationManyResponse as e4, type StorageFileMutationResponse as e5, type StorageFilePermissionRecord as e6, type StorageFileRetentionRequest as e7, type StorageFileVersionPathRequest as e8, type StorageFolderMutationResponse as e9, type StorageServerSideEncryptionOptions as eA, type StorageSetBucketCorsRequest as eB, type StorageSetBucketLifecycleRequest as eC, type StorageSetBucketPolicyRequest as eD, type StorageSetPublicAccessBlockRequest as eE, type StorageSignedPostPolicyRequest as eF, type StorageUpdateObjectRequest as eG, type StorageUploadUrlResponse as eH, type StorageUploadUrlResponseWithPut as eI, type TableQueryBuilder as eJ, type TreeStorageFoldersRequest as eK, type UnwrapOneOptions as eL, type UnwrapOptions as eM, type UpdateManyStorageFilesRequest as eN, type UpdateStorageCatalogRequest as eO, type UpdateStorageFileRequest as eP, assertInt as eQ, coerceInt as eR, createAthenaStorageError as eS, createClient as eT, createStorageModule as eU, getAthenaDebugAst as eV, isOk as eW, normalizeAthenaError as eX, parseBooleanFlag as eY, requireAffected as eZ, requireSuccess as e_, type StorageListFilesResponse as ea, type StorageListObjectsRequest as eb, type StorageMultipartAbortRequest as ec, type StorageMultipartCompletePartInput as ed, type StorageMultipartCompleteRequest as ee, type StorageMultipartCreateRequest as ef, type StorageMultipartListPartsRequest as eg, type StorageMultipartSignPartRequest as eh, type StorageObjectBaseRequest as ei, type StorageObjectCopyRequest as ej, type StorageObjectFolderCreateRequest as ek, type StorageObjectFolderDeleteRequest as el, type StorageObjectFolderRenameRequest as em, type StorageObjectPublicUrlRequest as en, type StorageObjectRequest as eo, type StorageObjectValidateRequest as ep, type StorageObjectVersionListRequest as eq, type StorageObjectVersionMutationRequest as er, type StoragePermissionCheckRequest as es, type StoragePermissionCheckResponse as et, type StoragePermissionGrantRequest as eu, type StoragePermissionListRequest as ev, type StoragePermissionListResponse as ew, type StoragePermissionRevokeRequest as ex, type StoragePresignUploadRequest as ey, type StoragePublicAccessBlockRequest as ez, type AthenaAdminEmailFailureGetQuery as f, unwrap as f0, unwrapOne as f1, unwrapRows as f2, verifyAthenaGatewayUrl as f3, withRetry as f4, type AthenaAuthFetchCompatibleInput as f5, type AthenaAdminEmailFailureGetResponse as g, type AthenaAdminEmailFailureListQuery as h, type AthenaAdminEmailFailureListResponse as i, type AthenaAdminEmailFailureUpdateRequest as j, type AthenaAdminEmailFailureUpdateResponse as k, type AthenaAdminEmailGetQuery as l, type AthenaAdminEmailGetResponse as m, type AthenaAdminEmailListQuery as n, type AthenaAdminEmailListResponse as o, type AthenaAdminEmailTemplateCreateRequest as p, type AthenaAdminEmailTemplateDeleteRequest as q, type AthenaAdminEmailTemplateGetQuery as r, type AthenaAdminEmailTemplateGetResponse as s, type AthenaAdminEmailTemplateListQuery as t, type AthenaAdminEmailTemplateListResponse as u, type AthenaAdminEmailTemplateRecord as v, type AthenaAdminEmailTemplateSendRequest as w, type AthenaAdminEmailTemplateSendResponse as x, type AthenaAdminEmailTemplateUpdateRequest as y, type AthenaAdminEmailUpdateRequest as z };