@xylex-group/athena 2.6.0 → 2.8.0

package/dist/model-form-DMed05gE.d.cts

@@ -0,0 +1,3037 @@
+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';
+
+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 AthenaAuthErrorCode = 'NETWORK_ERROR' | 'HTTP_ERROR' | 'INVALID_JSON' | 'UNKNOWN_ERROR';
+interface AthenaAuthErrorDetails {
+    code: AthenaAuthErrorCode;
+    message: string;
+    status: number;
+    endpoint?: AthenaAuthEndpointPath;
+    method?: AthenaAuthMethod;
+    requestId?: string;
+    hint?: string;
+    cause?: string;
+}
+interface AthenaAuthResult<T = unknown> {
+    ok: boolean;
+    status: number;
+    data: T | null;
+    error: string | null;
+    errorDetails?: AthenaAuthErrorDetails | null;
+    raw: unknown;
+}
+interface AthenaAuthUser {
+    id: string;
+    email: string;
+    name?: string | null;
+    image?: string | null;
+    emailVerified?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    username?: string | null;
+    displayUsername?: string | null;
+    twoFactorEnabled?: boolean;
+    role?: string | null;
+    banned?: boolean;
+    banReason?: string | null;
+    banExpires?: string | null;
+}
+interface AthenaAuthSession {
+    id: string;
+    expiresAt?: string;
+    token?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+    userId?: string;
+    impersonatedBy?: string | null;
+    activeOrganizationId?: string | null;
+}
+interface AthenaAuthSessionResponse {
+    session: AthenaAuthSession;
+    user: AthenaAuthUser;
+}
+interface AthenaAuthOrganization {
+    id: string;
+    name: string;
+    slug: string;
+    logo?: string | null;
+    metadata?: Record<string, unknown> | null;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface AthenaAuthOrganizationMember {
+    id: string;
+    organizationId?: string;
+    userId?: string;
+    role?: string | string[] | null;
+    createdAt?: string;
+    updatedAt?: string;
+    user?: AthenaAuthUser;
+}
+interface AthenaAuthOrganizationInvitation {
+    id: string;
+    email?: string;
+    role?: string | string[] | null;
+    organizationId?: string;
+    inviterId?: string;
+    teamId?: string | null;
+    status?: string;
+    expiresAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface AthenaEmailSignInRequest {
+    email: string;
+    password: string;
+    callbackURL?: string;
+    rememberMe?: boolean;
+}
+interface AthenaUsernameSignInRequest {
+    username: string;
+    password: string;
+    rememberMe?: boolean;
+}
+interface AthenaSocialSignInRequest {
+    provider: string;
+    callbackURL?: string;
+    newUserCallbackURL?: string;
+    errorCallbackURL?: string;
+    disableRedirect?: boolean;
+    idToken?: string;
+    scopes?: string[] | string;
+    requestSignUp?: boolean;
+    loginHint?: string;
+}
+interface AthenaEmailSignUpRequest {
+    name: string;
+    email: string;
+    password: string;
+    callbackURL?: string;
+}
+interface AthenaAuthSignInResponse {
+    redirect: false;
+    token: string;
+    url?: string | null;
+    user: AthenaAuthUser;
+}
+interface AthenaAuthSocialRedirectResponse {
+    url: string;
+    redirect: boolean;
+}
+interface AthenaAuthSignOutResponse {
+    success: boolean;
+}
+interface AthenaAuthStatusResponse {
+    status: boolean;
+}
+interface AthenaAuthRevokeSessionRequest {
+    token: string;
+}
+interface AthenaForgetPasswordRequest {
+    email: string;
+    redirectTo?: string;
+}
+interface AthenaResetPasswordRequest {
+    newPassword: string;
+    token?: string;
+}
+interface AthenaVerifyEmailRequest {
+    token: string;
+    callbackURL?: string;
+}
+interface AthenaSendVerificationEmailRequest {
+    email: string;
+    callbackURL?: string;
+}
+interface AthenaChangeEmailRequest {
+    newEmail: string;
+    callbackURL?: string;
+}
+interface AthenaChangePasswordRequest {
+    newPassword: string;
+    currentPassword: string;
+    revokeOtherSessions?: boolean;
+}
+interface AthenaUpdateUserRequest {
+    name?: string;
+    image?: string;
+}
+interface AthenaDeleteUserRequest {
+    callbackURL?: string;
+    password?: string;
+    token?: string;
+}
+interface AthenaDeleteUserCallbackRequest {
+    token?: string;
+    callbackURL?: string;
+}
+interface AthenaDeleteUserResponse {
+    success: boolean;
+    message?: string;
+}
+interface AthenaAuthEmailChangeResponse {
+    status: boolean;
+    message?: string | null;
+}
+interface AthenaLinkSocialRequest {
+    provider: string;
+    callbackURL?: string;
+    scopes?: string[] | string;
+}
+interface AthenaUnlinkAccountRequest {
+    providerId: string;
+    accountId?: string;
+}
+interface AthenaOAuthAccountTokenRequest {
+    providerId: string;
+    accountId?: string;
+    userId?: string;
+}
+interface AthenaOAuthTokenBundle {
+    tokenType?: string;
+    idToken?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    accessTokenExpiresAt?: string;
+    refreshTokenExpiresAt?: string;
+}
+interface AthenaAuthLinkedAccount {
+    id: string;
+    provider?: string;
+    accountId?: string;
+    scopes?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+type AthenaAuthPermissionSet = Record<string, unknown> | string[];
+type AthenaAuthLooseRecord = Record<string, unknown>;
+type AthenaAuthReactEmailProps = Record<string, unknown>;
+interface AthenaSetPasswordRequest {
+    newPassword: string;
+}
+interface AthenaAuthTokenQuery {
+    token: string;
+}
+interface AthenaAuthTokenVerificationResponse {
+    status: boolean;
+    message: string;
+}
+interface AthenaAuthEmailListQuery {
+    limit?: number;
+    offset?: number;
+}
+interface AthenaAuthEmailListResponse {
+    total: number;
+    limit: number;
+    offset: number;
+    emails: AthenaAuthLooseRecord[];
+}
+interface AthenaAuthHealthResponse {
+    status?: string;
+    service?: string;
+    version?: string;
+}
+interface AthenaAuthOkResponse {
+    ok: boolean;
+}
+interface AthenaAuthErrorResponse {
+    message: string;
+}
+interface AthenaAuthCallbackProviderRequest {
+    provider: string;
+    code: string;
+    state: string;
+}
+interface AthenaAuthCallbackProviderResponse {
+    token?: string;
+    user?: AthenaAuthLooseRecord;
+}
+interface AthenaTwoFactorGetTotpUriRequest {
+    password: string;
+}
+interface AthenaTwoFactorGetTotpUriResponse {
+    totpURI?: string;
+}
+interface AthenaTwoFactorVerifyTotpRequest {
+    code: string;
+    trustDevice?: string;
+}
+interface AthenaTwoFactorVerifyTotpResponse {
+    status?: boolean;
+}
+interface AthenaTwoFactorVerifyOtpRequest {
+    code: string;
+    trustDevice?: string;
+}
+interface AthenaTwoFactorVerifyOtpResponse {
+    token: string;
+    user: AthenaAuthUser;
+}
+interface AthenaTwoFactorVerifyBackupCodeRequest {
+    code: string;
+    disableSession?: string;
+    trustDevice?: string;
+}
+interface AthenaTwoFactorSessionSnapshot {
+    token: string;
+    userId: string;
+    createdAt: string;
+    expiresAt: string;
+}
+interface AthenaTwoFactorVerifyBackupCodeResponse {
+    user: AthenaAuthUser;
+    session: AthenaTwoFactorSessionSnapshot;
+}
+interface AthenaTwoFactorGenerateBackupCodesRequest {
+    password: string;
+}
+interface AthenaTwoFactorGenerateBackupCodesResponse {
+    status: true;
+    backupCodes: string[];
+}
+interface AthenaTwoFactorEnableRequest {
+    password: string;
+    issuer?: string;
+}
+interface AthenaTwoFactorEnableResponse {
+    totpURI?: string;
+    backupCodes?: string[];
+}
+interface AthenaTwoFactorDisableRequest {
+    password: string;
+}
+interface AthenaTwoFactorDisableResponse {
+    status?: boolean;
+}
+interface AthenaPasskeyCredentialDescriptor {
+    id?: string;
+    type?: string;
+    transports?: string[];
+}
+interface AthenaPasskeyPublicKeyCredentialParam {
+    type?: string;
+    alg?: number;
+}
+interface AthenaPasskeyUserDescriptor {
+    id?: string;
+    name?: string;
+    displayName?: string;
+}
+interface AthenaPasskeyRelyingParty {
+    name?: string;
+    id?: string;
+}
+interface AthenaPasskeyAuthenticatorSelection {
+    authenticatorAttachment?: string;
+    requireResidentKey?: boolean;
+    userVerification?: string;
+}
+interface AthenaPasskeyOptionsResponse {
+    challenge?: string;
+    rp?: AthenaPasskeyRelyingParty;
+    user?: AthenaPasskeyUserDescriptor;
+    timeout?: number;
+    allowCredentials?: AthenaPasskeyCredentialDescriptor[];
+    excludeCredentials?: AthenaPasskeyCredentialDescriptor[];
+    pubKeyCredParams?: AthenaPasskeyPublicKeyCredentialParam[];
+    userVerification?: string;
+    authenticatorSelection?: AthenaPasskeyAuthenticatorSelection;
+    attestation?: string;
+    extensions?: AthenaAuthLooseRecord;
+}
+interface AthenaPasskeyRecord {
+    id: string;
+    name?: string | null;
+    publicKey?: string;
+    userId: string;
+    credentialID?: string;
+    counter?: number;
+    deviceType?: string;
+    backedUp?: boolean;
+    transports?: string;
+    createdAt?: string;
+}
+interface AthenaPasskeyVerifyRegistrationRequest {
+    response: string;
+    name?: string;
+}
+interface AthenaPasskeyVerifyAuthenticationRequest {
+    response: string;
+}
+interface AthenaPasskeyVerifyAuthenticationResponse {
+    session: AthenaAuthSession;
+    user: AthenaAuthUser;
+}
+interface AthenaPasskeyDeleteRequest {
+    id: string;
+}
+interface AthenaPasskeyDeleteResponse {
+    status: boolean;
+}
+interface AthenaPasskeyUpdateRequest {
+    id: string;
+    name: string;
+}
+interface AthenaPasskeyUpdateResponse {
+    passkey: AthenaPasskeyRecord;
+}
+interface AthenaAdminSetRoleRequest {
+    userId: string;
+    role: string;
+}
+interface AthenaAdminCreateUserRequest {
+    email: string;
+    password: string;
+    name: string;
+    role?: string;
+    data?: string;
+}
+interface AthenaAdminTargetUserRequest {
+    userId: string;
+}
+interface AthenaAdminBanUserRequest extends AthenaAdminTargetUserRequest {
+    banReason?: string;
+    banExpiresIn?: string;
+}
+type AthenaAuthSearchOperator = 'contains' | 'starts_with' | 'ends_with';
+type AthenaAuthFilterOperator = 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'in' | 'not_in' | 'contains' | 'starts_with' | 'ends_with';
+type AthenaAdminListUsersSearchOperator = AthenaAuthSearchOperator;
+type AthenaAdminListUsersFilterOperator = AthenaAuthFilterOperator;
+interface AthenaAdminListUsersQuery {
+    searchValue?: string;
+    searchField?: string;
+    searchOperator?: AthenaAdminListUsersSearchOperator;
+    limit?: number | string;
+    offset?: number | string;
+    sortBy?: string;
+    sortDirection?: string;
+    filterField?: string;
+    filterValue?: string;
+    filterOperator?: AthenaAdminListUsersFilterOperator;
+}
+interface AthenaAdminListUsersResponse {
+    users: AthenaAuthUser[];
+    total: number;
+    limit?: number;
+    offset?: number;
+}
+interface AthenaAdminListUserSessionsRequest {
+    userId: string;
+}
+interface AthenaAdminListUserSessionsResponse {
+    sessions: AthenaAuthSession[];
+}
+interface AthenaAdminImpersonateResponse {
+    session: AthenaAuthSession;
+    user: AthenaAuthUser;
+}
+interface AthenaAdminStopImpersonatingRequest {
+    userId?: string;
+}
+interface AthenaAdminRevokeUserSessionRequest {
+    sessionToken: string;
+    userId: string;
+    sessionId?: string;
+}
+interface AthenaAdminRevokeUserSessionsRequest {
+    userId: string;
+}
+interface AthenaAdminSetUserPasswordRequest {
+    userId: string;
+    newPassword: string;
+}
+interface AthenaAdminUserResponse {
+    user: AthenaAuthUser;
+}
+interface AthenaAdminSuccessResponse {
+    success: boolean;
+}
+interface AthenaAdminHasPermissionRequest {
+    permission?: AthenaAuthPermissionSet;
+    permissions: AthenaAuthPermissionSet;
+}
+interface AthenaAdminHasPermissionResponse {
+    success: boolean;
+    error?: string;
+}
+interface AthenaAdminApiKeyCreateRequest {
+    name?: string;
+    expiresIn?: number;
+    athenaClientName?: string;
+    permissions?: AthenaAuthLooseRecord;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminApiKeyCreateResponse {
+    key?: string;
+    apiKey?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminAthenaClientCreateRequest {
+    clientName: string;
+    description?: string;
+    isActive?: boolean;
+    pgUriEnvVar?: string;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminAthenaClientListResponse {
+    athenaClients?: AthenaAuthLooseRecord[];
+}
+interface AthenaAdminAuditLogListQuery {
+    limit?: number;
+    offset?: number;
+    actorUserId?: string;
+    action?: string;
+    targetType?: string;
+    targetId?: string;
+    success?: boolean;
+    createdAfter?: string;
+    createdBefore?: string;
+}
+interface AthenaAdminAuditLogListResponse {
+    total?: number;
+    limit?: number;
+    offset?: number;
+    auditLogs?: AthenaAuthLooseRecord[];
+}
+interface AthenaAdminEmailListQuery {
+    limit?: number;
+    offset?: number;
+    recipientEmail?: string;
+    provider?: string;
+    flow?: string;
+    subjectContains?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+}
+interface AthenaAdminEmailListResponse {
+    total?: number;
+    limit?: number;
+    offset?: number;
+    emails?: AthenaAuthLooseRecord[];
+}
+interface AthenaAdminEmailGetQuery {
+    id: string;
+}
+interface AthenaAdminEmailGetResponse {
+    email?: AthenaAuthLooseRecord;
+}
+interface AthenaAuthReactEmailRenderInput {
+    /**
+     * React email element instance (for example: `<WelcomeEmail {...props} />`).
+     */
+    element?: unknown;
+    /**
+     * React email component function. Use with `props` when you prefer component + props inputs.
+     */
+    component?: AthenaAuthReactEmailComponent;
+    /**
+     * Props passed to `component` when `element` is omitted.
+     */
+    props?: AthenaAuthReactEmailProps;
+    /**
+     * When true, run `pretty(...)` on rendered HTML when available.
+     */
+    pretty?: boolean;
+    /**
+     * Override plain-text output. If omitted, text is auto-derived when possible.
+     */
+    text?: string;
+    /**
+     * Disable derived plain-text generation. Defaults to `true`.
+     */
+    includePlainText?: boolean;
+}
+type AthenaAuthReactEmailComponent<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps> = (props: TProps) => unknown;
+interface AthenaAuthReactEmailRenderOptions {
+    pretty?: boolean;
+    includePlainText?: boolean;
+}
+type AthenaAuthReactEmailEventPhase = 'render:start' | 'render:success' | 'render:error';
+interface AthenaAuthReactEmailRenderEvent {
+    phase: AthenaAuthReactEmailEventPhase;
+    timestamp: string;
+    route?: string;
+    durationMs?: number;
+    message?: string;
+    error?: string;
+}
+interface AthenaAuthReactEmailConfig {
+    /**
+     * Optional default render settings used when request payloads omit `pretty` or `includePlainText`.
+     */
+    defaults?: AthenaAuthReactEmailRenderOptions;
+    /**
+     * Optional observer for render lifecycle events.
+     */
+    observe?: (event: AthenaAuthReactEmailRenderEvent) => void;
+}
+interface AthenaAdminEmailCreateRequest {
+    recipientEmail: string;
+    subject: string;
+    fromAddress: string;
+    fromName?: string;
+    textBody?: string;
+    htmlBody?: string;
+    /**
+     * Optional React Email render input. When provided, `htmlBody` is derived automatically.
+     */
+    react?: AthenaAuthReactEmailRenderInput;
+    provider: string;
+    flow?: string;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailUpdateRequest {
+    id: string;
+    recipientEmail?: string;
+    subject?: string;
+    fromAddress?: string;
+    fromName?: string | null;
+    textBody?: string | null;
+    htmlBody?: string | null;
+    /**
+     * Optional React Email render input. When provided, `htmlBody` is derived automatically.
+     */
+    react?: AthenaAuthReactEmailRenderInput;
+    provider?: string;
+    flow?: string | null;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailUpdateResponse {
+    email?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailDeleteRequest {
+    id: string;
+}
+interface AthenaAdminEmailFailureListQuery {
+    limit?: number;
+    offset?: number;
+    recipientEmail?: string;
+    provider?: string;
+    flow?: string;
+    resolved?: boolean;
+    createdAfter?: string;
+    createdBefore?: string;
+}
+interface AthenaAdminEmailFailureListResponse {
+    total?: number;
+    limit?: number;
+    offset?: number;
+    emailSendFailures?: AthenaAuthLooseRecord[];
+}
+interface AthenaAdminEmailFailureGetQuery {
+    id: string;
+}
+interface AthenaAdminEmailFailureGetResponse {
+    emailSendFailure?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailFailureCreateRequest {
+    userId?: string;
+    recipientEmail: string;
+    flow: string;
+    provider?: string;
+    errorMessage: string;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailFailureUpdateRequest {
+    id: string;
+    resolved?: boolean;
+    resolutionNote?: string | null;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailFailureUpdateResponse {
+    emailSendFailure?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailFailureDeleteRequest {
+    id: string;
+}
+interface AthenaAdminEmailTemplateListQuery {
+    limit?: number;
+    offset?: number;
+    templateKey?: string;
+    locale?: string;
+    isActive?: boolean;
+}
+interface AthenaAdminEmailTemplateListResponse {
+    total?: number;
+    limit?: number;
+    offset?: number;
+    emailTemplates?: AthenaAuthLooseRecord[];
+}
+interface AthenaAdminEmailTemplateCreateRequest {
+    templateKey: string;
+    locale?: string;
+    subjectTemplate: string;
+    textTemplate?: string;
+    htmlTemplate?: string;
+    /**
+     * Optional React Email render input. When provided, `htmlTemplate` is derived automatically.
+     */
+    react?: AthenaAuthReactEmailRenderInput;
+    variables?: string[];
+    isActive?: boolean;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailTemplateUpdateRequest {
+    id: string;
+    templateKey?: string;
+    locale?: string;
+    subjectTemplate?: string;
+    textTemplate?: string | null;
+    htmlTemplate?: string | null;
+    /**
+     * Optional React Email render input. When provided, `htmlTemplate` is derived automatically.
+     */
+    react?: AthenaAuthReactEmailRenderInput;
+    variables?: string[];
+    isActive?: boolean;
+    metadata?: AthenaAuthLooseRecord;
+}
+interface AthenaAdminEmailTemplateDeleteRequest {
+    id: string;
+}
+interface AthenaAdminEmailTemplateGetQuery {
+    id: string;
+}
+interface AthenaAdminEmailTemplateGetResponse {
+    emailTemplate?: AthenaAuthLooseRecord;
+}
+interface AthenaApiKeyCreateRequest {
+    name?: string;
+    expiresIn: string;
+    userId?: string;
+    prefix?: string;
+    remaining: string;
+    metadata?: string;
+    refillAmount?: string;
+    refillInterval?: string;
+    rateLimitTimeWindow?: string;
+    rateLimitMax?: string;
+    rateLimitEnabled?: string;
+    permissions?: string;
+}
+interface AthenaApiKeyRecord {
+    id: string;
+    name?: string | null;
+    start?: string | null;
+    prefix?: string | null;
+    userId: string;
+    refillInterval?: number | null;
+    refillAmount?: number | null;
+    lastRefillAt?: string | null;
+    enabled: boolean;
+    rateLimitEnabled: boolean;
+    rateLimitTimeWindow?: number | null;
+    rateLimitMax?: number | null;
+    requestCount: number;
+    remaining?: number | null;
+    lastRequest?: string | null;
+    expiresAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    metadata?: AthenaAuthLooseRecord | null;
+    permissions?: string | null;
+    key?: string;
+}
+interface AthenaApiKeyGetQuery {
+    id?: string;
+}
+interface AthenaApiKeyUpdateRequest {
+    keyId: string;
+    userId?: string;
+    name?: string;
+    enabled?: string;
+    remaining?: string;
+    refillAmount?: string;
+    refillInterval?: string;
+    metadata?: string;
+    expiresIn: string;
+    rateLimitEnabled?: string;
+    rateLimitTimeWindow?: string;
+    rateLimitMax?: string;
+    permissions: string;
+}
+interface AthenaApiKeyDeleteRequest {
+    keyId: string;
+}
+interface AthenaApiKeyVerifyRequest {
+    key: string;
+    permissions?: AthenaAuthLooseRecord;
+}
+interface AthenaApiKeyVerifyResponse {
+    valid?: boolean;
+    error?: {
+        message?: string;
+        code?: string;
+    } | null;
+    key?: AthenaAuthLooseRecord | null;
+}
+interface AthenaApiKeyDeleteAllExpiredResponse {
+    deleted?: number;
+}
+interface AthenaAuthOrganizationCreateRequest {
+    name: string;
+    slug: string;
+    logo?: string;
+    metadata?: Record<string, unknown>;
+    userId?: string;
+    keepCurrentActiveOrganization?: boolean;
+}
+interface AthenaAuthOrganizationCheckSlugRequest {
+    slug: string;
+}
+interface AthenaAuthOrganizationSetActiveRequest {
+    organizationId?: string | null;
+    organizationSlug?: string | null;
+}
+interface AthenaAuthOrganizationGetFullQuery {
+    organizationId?: string;
+    organizationSlug?: string;
+    membersLimit?: number;
+}
+interface AthenaAuthOrganizationUpdateRequest {
+    data: {
+        name?: string;
+        slug?: string;
+        logo?: string;
+        metadata?: Record<string, unknown> | null;
+    };
+    organizationId?: string;
+}
+interface AthenaAuthOrganizationDeleteRequest {
+    organizationId: string;
+}
+interface AthenaAuthOrganizationInviteMemberRequest {
+    email: string;
+    role: string | string[];
+    organizationId?: string;
+    resend?: boolean;
+    teamId?: string;
+}
+interface AthenaAuthOrganizationInvitationActionRequest {
+    invitationId: string;
+}
+interface AthenaAuthOrganizationGetInvitationQuery {
+    id: string;
+}
+interface AthenaAuthOrganizationListInvitationsQuery {
+    organizationId?: string;
+}
+interface AthenaAuthOrganizationListUserInvitationsQuery {
+    email?: string;
+}
+type AthenaAuthOrganizationListMembersFilterOperator = AthenaAuthFilterOperator;
+interface AthenaAuthOrganizationListMembersQuery {
+    organizationId?: string;
+    limit?: number;
+    offset?: number;
+    sortBy?: string;
+    sortDirection?: 'asc' | 'desc';
+    filterField?: string;
+    filterOperator?: AthenaAuthOrganizationListMembersFilterOperator;
+    filterValue?: string | number | boolean | string[] | number[];
+}
+interface AthenaAuthOrganizationRemoveMemberRequest {
+    memberIdOrEmail: string;
+    organizationId?: string;
+}
+interface AthenaAuthOrganizationUpdateMemberRoleRequest {
+    role: string | string[];
+    memberId: string;
+    organizationId?: string;
+}
+interface AthenaAuthOrganizationLeaveRequest {
+    organizationId: string;
+}
+interface AthenaAuthRequestInput {
+    endpoint: AthenaAuthEndpointPath;
+    method?: AthenaAuthMethod;
+    body?: unknown;
+    query?: Record<string, AthenaAuthQueryValue>;
+    fetchOptions?: AthenaAuthCallOptions;
+}
+interface AthenaAuthCallOptions {
+    baseUrl?: string;
+    apiKey?: string;
+    bearerToken?: string;
+    headers?: Record<string, string>;
+    credentials?: AthenaAuthCredentials;
+    signal?: AbortSignal;
+}
+interface AthenaAuthFetchCompatibleInput {
+    fetchOptions?: AthenaAuthCallOptions;
+}
+interface AthenaAuthClientConfig extends AthenaAuthCallOptions {
+    fetch?: typeof fetch;
+    reactEmail?: AthenaAuthReactEmailConfig;
+}
+interface AthenaAuthEmailTemplateDefinition<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps> {
+    component: AthenaAuthReactEmailComponent<TProps>;
+    templateKey?: string;
+    subjectTemplate?: string;
+    defaults?: AthenaAuthReactEmailRenderOptions;
+}
+interface AthenaAuthEmailTemplateReactOverrides {
+    pretty?: boolean;
+    text?: string;
+    includePlainText?: boolean;
+}
+interface AthenaAuthEmailTemplateCreateFromDefinitionInput<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps> extends Omit<AthenaAdminEmailTemplateCreateRequest, 'react' | 'htmlTemplate' | 'textTemplate' | 'variables' | 'templateKey' | 'subjectTemplate'> {
+    props: TProps;
+    templateKey?: string;
+    subjectTemplate?: string;
+    react?: AthenaAuthEmailTemplateReactOverrides;
+}
+interface AthenaAuthEmailTemplateUpdateFromDefinitionInput<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps> extends Omit<AthenaAdminEmailTemplateUpdateRequest, 'react' | 'htmlTemplate' | 'textTemplate' | 'variables'> {
+    props: TProps;
+    react?: AthenaAuthEmailTemplateReactOverrides;
+}
+interface AthenaAuthEmailTemplateBuilder<TProps extends AthenaAuthReactEmailProps = AthenaAuthReactEmailProps> {
+    component: AthenaAuthReactEmailComponent<TProps>;
+    react: (props: TProps, overrides?: AthenaAuthEmailTemplateReactOverrides) => AthenaAuthReactEmailRenderInput;
+    toTemplateCreate: (input: AthenaAuthEmailTemplateCreateFromDefinitionInput<TProps>) => AthenaAdminEmailTemplateCreateRequest;
+    toTemplateUpdate: (input: AthenaAuthEmailTemplateUpdateFromDefinitionInput<TProps>) => AthenaAdminEmailTemplateUpdateRequest;
+}
+type AthenaAuthGenericInput = AthenaAuthFetchCompatibleInput & Record<string, unknown>;
+type AthenaAuthGenericQueryInput = AthenaAuthFetchCompatibleInput & {
+    query?: Record<string, AthenaAuthQueryValue>;
+};
+type AthenaAuthResetPasswordBinding = ((input: AthenaResetPasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>) & {
+    token: (input: {
+        token: string;
+        callbackURL?: string;
+    } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
+        token?: string;
+    }>>;
+};
+type AthenaAuthSessionRevokeBinding = (input: (AthenaAuthRevokeSessionRequest & AthenaAuthFetchCompatibleInput) | (AthenaAuthRevokeSessionRequest[] & AthenaAuthFetchCompatibleInput), options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+type AthenaAuthAdminUserSessionRevokeBinding = (input: (AthenaAdminRevokeUserSessionRequest & AthenaAuthFetchCompatibleInput) | (AthenaAdminRevokeUserSessionsRequest & AthenaAuthFetchCompatibleInput) | ({
+    sessions: AthenaAdminRevokeUserSessionRequest[];
+} & AthenaAuthFetchCompatibleInput) | ((AthenaAdminRevokeUserSessionRequest & AthenaAuthFetchCompatibleInput)[]), options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+interface AthenaAuthOrganizationBindings {
+    /** Create an organization. Route: `POST /organization/create`. */
+    create: (input: AthenaAuthOrganizationCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganization>>;
+    /** Update an organization. Route: `POST /organization/update`. */
+    update: (input: AthenaAuthOrganizationUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganization>>;
+    /** Delete an organization. Route: `POST /organization/delete`. */
+    delete: (input: AthenaAuthOrganizationDeleteRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    /** Set active organization for current session. Route: `POST /organization/set-active`. */
+    setActive: (input: AthenaAuthOrganizationSetActiveRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    /** List organizations visible to the current user. Route: `GET /organization/list`. */
+    list: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganization[]>>;
+    /** Get organization details including related members/invitations. Route: `GET /organization/get-full-organization`. */
+    getFull: (input?: {
+        query?: AthenaAuthOrganizationGetFullQuery;
+    } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
+        organization: AthenaAuthOrganization;
+        members?: AthenaAuthOrganizationMember[];
+        invitations?: AthenaAuthOrganizationInvitation[];
+    }>>;
+    /** Check if an organization slug is available. Route: `POST /organization/check-slug`. */
+    checkSlug: (input: AthenaAuthOrganizationCheckSlugRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
+        available: boolean;
+    }>>;
+    /** Leave an organization. Route: `POST /organization/leave`. */
+    leave: (input: AthenaAuthOrganizationLeaveRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    /** List invitations for the current user. Route: `GET /organization/list-user-invitations`. */
+    listUserInvitations: (input?: {
+        query?: AthenaAuthOrganizationListUserInvitationsQuery;
+    } & 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>>;
+    invitation: {
+        /** Cancel an organization invitation. Route: `POST /organization/cancel-invitation`. */
+        cancel: (input: AthenaAuthOrganizationInvitationActionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+        /** Accept an organization invitation. Route: `POST /organization/accept-invitation`. */
+        accept: (input: AthenaAuthOrganizationInvitationActionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+        /** Get an invitation by id. Route: `GET /organization/get-invitation`. */
+        get: (input: {
+            query: AthenaAuthOrganizationGetInvitationQuery;
+        } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganizationInvitation>>;
+        /** Reject an organization invitation. Route: `POST /organization/reject-invitation`. */
+        reject: (input: AthenaAuthOrganizationInvitationActionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+        /** List invitations for an organization. Route: `GET /organization/list-invitations`. */
+        list: (input?: {
+            query?: AthenaAuthOrganizationListInvitationsQuery;
+        } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganizationInvitation[]>>;
+    };
+    member: {
+        /** Remove an organization member. Route: `POST /organization/remove-member`. */
+        remove: (input: AthenaAuthOrganizationRemoveMemberRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+        /** Update a member role. Route: `POST /organization/update-member-role`. */
+        updateRole: (input: AthenaAuthOrganizationUpdateMemberRoleRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+        /** Invite a member to an organization. Route: `POST /organization/invite-member`. */
+        invite: (input: AthenaAuthOrganizationInviteMemberRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganizationInvitation>>;
+        /** Get the active organization member context for the current session. Route: `GET /organization/get-active-member`. */
+        getActive: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganizationMember>>;
+        /** List organization members. Route: `GET /organization/list-members`. */
+        list: (input?: {
+            query?: AthenaAuthOrganizationListMembersQuery;
+        } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOrganizationMember[]>>;
+    };
+}
+interface AthenaAuthBindings {
+    /** Get current session. Route: `GET /get-session`. */
+    getSession: AthenaAuthSdkClient['getSession'];
+    /** Sign out current session. Route: `POST /sign-out`. */
+    signOut: AthenaAuthSdkClient['signOut'];
+    /** Trigger password reset email flow. Route: `POST /forget-password`. */
+    forgetPassword: AthenaAuthSdkClient['forgetPassword'];
+    /** Reset password (`POST /reset-password`) and token resolver (`GET /reset-password/{token}`). */
+    resetPassword: AthenaAuthResetPasswordBinding;
+    /** Set password for the current authenticated user. Route: `POST /set-password`. */
+    setPassword: (input: AthenaSetPasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    /** Verify email token. Route: `GET /verify-email`. */
+    verifyEmail: AthenaAuthSdkClient['verifyEmail'];
+    /** Send verification email. Route: `POST /send-verification-email`. */
+    sendVerificationEmail: AthenaAuthSdkClient['sendVerificationEmail'];
+    /** Start change-email flow. Route: `POST /change-email`. */
+    changeEmail: AthenaAuthSdkClient['changeEmail'];
+    /** Verify pending email change. Route: `GET /change-email/verify`. */
+    changeEmailVerify: (input: {
+        query: AthenaAuthTokenQuery;
+    } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthTokenVerificationResponse>>;
+    /** Verify pending delete-user flow. Route: `GET /delete-user/verify`. */
+    deleteUserVerify: (input: {
+        query: AthenaAuthTokenQuery;
+    } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthTokenVerificationResponse>>;
+    /** Change current user password. Route: `POST /change-password`. */
+    changePassword: AthenaAuthSdkClient['changePassword'];
+    user: {
+        /** Update current user profile fields. Route: `POST /update-user`. */
+        update: AthenaAuthSdkClient['updateUser'];
+        /** Delete current user. Route: `POST /delete-user`. */
+        delete: AthenaAuthSdkClient['deleteUser'];
+        email: {
+            /**
+             * List email identities for current user.
+             * Routes: primary `GET /email/list`; falls back to `GET /email-list` on `404`.
+             */
+            list: (input?: {
+                query?: AthenaAuthEmailListQuery;
+            } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthEmailListResponse>>;
+        };
+    };
+    session: {
+        /** List user sessions. Route: `GET /list-sessions`. */
+        list: AthenaAuthSdkClient['listSessions'];
+        /** Revoke one or multiple sessions; collapses to `/revoke-session` or `/revoke-sessions` by payload shape. */
+        revoke: AthenaAuthSessionRevokeBinding;
+        /** Revoke all other sessions for current user. Route: `POST /revoke-other-sessions`. */
+        revokeOther: AthenaAuthSdkClient['revokeOtherSessions'];
+    };
+    social: {
+        /** Link a social provider to current user. Route: `POST /link-social`. */
+        link: AthenaAuthSdkClient['linkSocial'];
+    };
+    account: {
+        /** List linked provider accounts. Route: `GET /list-accounts`. */
+        list: AthenaAuthSdkClient['listAccounts'];
+        /** Unlink a provider account. Route: `POST /unlink-account`. */
+        unlink: AthenaAuthSdkClient['unlinkAccount'];
+    };
+    deleteUser: {
+        /** Callback endpoint for delete-user verification flows. Route: `GET /delete-user/callback`. */
+        callback: AthenaAuthSdkClient['deleteUserCallback'];
+    };
+    /** Refresh provider token. Route: `POST /refresh-token`. */
+    refreshToken: AthenaAuthSdkClient['refreshToken'];
+    /** Get provider access token. Route: `POST /get-access-token`. */
+    getAccessToken: AthenaAuthSdkClient['getAccessToken'];
+    /** Auth health route. Primary `GET /health`; falls back to `GET /ok` on `404`. */
+    health: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthHealthResponse>>;
+    /** Health route passthrough. Route: `GET /ok`. */
+    ok: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthOkResponse>>;
+    /** Error route passthrough. Route: `GET /error`. */
+    error: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthErrorResponse | string>>;
+    twoFactor: {
+        /** Get TOTP URI for setup. Route: `POST /two-factor/get-totp-uri`. */
+        getTotpUri: (input: AthenaTwoFactorGetTotpUriRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaTwoFactorGetTotpUriResponse>>;
+        /** Verify TOTP code. Route: `POST /two-factor/verify-totp`. */
+        verifyTotp: (input: AthenaTwoFactorVerifyTotpRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaTwoFactorVerifyTotpResponse>>;
+        /** Send one-time passcode (OTP). Route: `POST /two-factor/send-otp`. */
+        sendOtp: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+        /** Verify OTP code. Route: `POST /two-factor/verify-otp`. */
+        verifyOtp: (input: AthenaTwoFactorVerifyOtpRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaTwoFactorVerifyOtpResponse>>;
+        /** Verify backup code. Route: `POST /two-factor/verify-backup-code`. */
+        verifyBackupCode: (input: AthenaTwoFactorVerifyBackupCodeRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaTwoFactorVerifyBackupCodeResponse>>;
+        /** Generate backup codes. Route: `POST /two-factor/generate-backup-codes`. */
+        generateBackupCodes: (input: AthenaTwoFactorGenerateBackupCodesRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaTwoFactorGenerateBackupCodesResponse>>;
+        /** Enable two-factor auth. Route: `POST /two-factor/enable`. */
+        enable: (input: AthenaTwoFactorEnableRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaTwoFactorEnableResponse>>;
+        /** Disable two-factor auth. Route: `POST /two-factor/disable`. */
+        disable: (input: AthenaTwoFactorDisableRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaTwoFactorDisableResponse>>;
+    };
+    passkey: {
+        /** Generate WebAuthn registration options. Route: `GET /passkey/generate-register-options`. */
+        generateRegisterOptions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaPasskeyOptionsResponse>>;
+        /** Generate WebAuthn authentication options. Route: `POST /passkey/generate-authenticate-options`. */
+        generateAuthenticateOptions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaPasskeyOptionsResponse>>;
+        /** Verify passkey registration response. Route: `POST /passkey/verify-registration`. */
+        verifyRegistration: (input: AthenaPasskeyVerifyRegistrationRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaPasskeyRecord>>;
+        /** Verify passkey authentication response. Route: `POST /passkey/verify-authentication`. */
+        verifyAuthentication: (input: AthenaPasskeyVerifyAuthenticationRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaPasskeyVerifyAuthenticationResponse>>;
+        /** List current user's passkeys. Route: `GET /passkey/list-user-passkeys`. */
+        listUserPasskeys: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaPasskeyRecord[]>>;
+        /** Delete a passkey. Route: `POST /passkey/delete-passkey`. */
+        deletePasskey: (input: AthenaPasskeyDeleteRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaPasskeyDeleteResponse>>;
+        /** Update a passkey metadata record. Route: `POST /passkey/update-passkey`. */
+        updatePasskey: (input: AthenaPasskeyUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaPasskeyUpdateResponse>>;
+        /** Return related origins for WebAuthn. Route: `GET /.well-known/webauthn`. */
+        getRelatedOrigins: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
+            origins?: string[];
+        }>>;
+    };
+    admin: {
+        role: {
+            /** Set a user role. Route: `POST /admin/set-role`. */
+            set: (input: AthenaAdminSetRoleRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminUserResponse>>;
+        };
+        user: {
+            /** List users. Route: `GET /admin/list-users`. */
+            list: (input?: {
+                query?: AthenaAdminListUsersQuery;
+            } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminListUsersResponse>>;
+            /** Create user. Route: `POST /admin/create-user`. */
+            create: (input: AthenaAdminCreateUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminUserResponse>>;
+            /** Unban user. Route: `POST /admin/unban-user`. */
+            unban: (input: AthenaAdminTargetUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminUserResponse>>;
+            /** Ban user. Route: `POST /admin/ban-user`. */
+            ban: (input: AthenaAdminBanUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminUserResponse>>;
+            /** Start impersonation. Route: `POST /admin/impersonate-user`. */
+            impersonate: (input: AthenaAdminTargetUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminImpersonateResponse>>;
+            /** Stop impersonation. Route: `POST /admin/stop-impersonating`. */
+            stopImpersonating: (input?: AthenaAdminStopImpersonatingRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLooseRecord>>;
+            /** Remove user. Route: `POST /admin/remove-user`. */
+            remove: (input: AthenaAdminTargetUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+            /** Set user password. Route: `POST /admin/set-user-password`. */
+            setPassword: (input: AthenaAdminSetUserPasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+            session: {
+                /** List sessions for a target user. Route: `POST /admin/list-user-sessions`. */
+                list: (input: AthenaAdminListUserSessionsRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminListUserSessionsResponse>>;
+                /**
+                 * Revoke one or multiple sessions; collapses to `/admin/revoke-user-session` or
+                 * `/admin/revoke-user-sessions`. `userId` is required and plural payloads must share one `userId`.
+                 */
+                revoke: AthenaAuthAdminUserSessionRevokeBinding;
+            };
+        };
+        /** Check permission under admin policy. Route: `POST /admin/has-permission`. */
+        hasPermission: (input: AthenaAdminHasPermissionRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminHasPermissionResponse>>;
+        apiKey: {
+            /** Create admin-scoped API key. Route: `POST /admin/api-key/create`. */
+            create: (input?: AthenaAdminApiKeyCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminApiKeyCreateResponse>>;
+        };
+        athenaClient: {
+            /** Create Athena client credentials. Route: `POST /admin/athena-client/create`. */
+            create: (input: AthenaAdminAthenaClientCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLooseRecord>>;
+            /** List Athena client credentials. Route: `GET /admin/athena-client/list`. */
+            list: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminAthenaClientListResponse>>;
+        };
+        auditLog: {
+            /** List auth audit events. Route: `GET /admin/audit-log/list`. */
+            list: (input?: {
+                query?: AthenaAdminAuditLogListQuery;
+            } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminAuditLogListResponse>>;
+        };
+        email: {
+            /** List emails. Route: `GET /admin/email/list`. */
+            list: (input?: {
+                query?: AthenaAdminEmailListQuery;
+            } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailListResponse>>;
+            /** Get a specific email record. Route: `GET /admin/email/get`. */
+            get: (input: {
+                query: AthenaAdminEmailGetQuery;
+            } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailGetResponse>>;
+            /** Create an email record. Route: `POST /admin/email/create`. */
+            create: (input: AthenaAdminEmailCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+            /** Update an email record. Route: `POST /admin/email/update`. */
+            update: (input: AthenaAdminEmailUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailUpdateResponse>>;
+            /** Delete an email record. Route: `POST /admin/email/delete`. */
+            delete: (input: AthenaAdminEmailDeleteRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+            failure: {
+                /** List email failure records. Route: `GET /admin/email-failure/list`. */
+                list: (input?: {
+                    query?: AthenaAdminEmailFailureListQuery;
+                } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailFailureListResponse>>;
+                /** Get an email failure record. Route: `GET /admin/email-failure/get`. */
+                get: (input: {
+                    query: AthenaAdminEmailFailureGetQuery;
+                } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailFailureGetResponse>>;
+                /** Create an email failure record. Route: `POST /admin/email-failure/create`. */
+                create: (input: AthenaAdminEmailFailureCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+                /** Update an email failure record. Route: `POST /admin/email-failure/update`. */
+                update: (input: AthenaAdminEmailFailureUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailFailureUpdateResponse>>;
+                /** Delete an email failure record. Route: `POST /admin/email-failure/delete`. */
+                delete: (input: AthenaAdminEmailFailureDeleteRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+            };
+            template: {
+                /** List email templates. Route: `GET /admin/email-template/list`. */
+                list: (input?: {
+                    query?: AthenaAdminEmailTemplateListQuery;
+                } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminEmailTemplateListResponse>>;
+                /** Get email template by ID. Route: `GET /admin/email-template/get`. */
+                get: (input: {
+                    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>>;
+                /** Update email template. Route: `POST /admin/email-template/update`. */
+                update: (input: AthenaAdminEmailTemplateUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLooseRecord>>;
+                /** Delete email template. Route: `POST /admin/email-template/delete`. */
+                delete: (input: AthenaAdminEmailTemplateDeleteRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+            };
+        };
+        emailTemplate: {
+            /** Get email template by ID. Route: `GET /admin/email-template/get`. */
+            get: (input: {
+                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>>;
+            /** 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`. */
+            list: (input?: {
+                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>>;
+        };
+    };
+    apiKey: {
+        /** Create API key. Route: `POST /api-key/create`. */
+        create: (input: AthenaApiKeyCreateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaApiKeyRecord>>;
+        /** Get API key metadata. Route: `GET /api-key/get`. */
+        get: (input?: {
+            query?: AthenaApiKeyGetQuery;
+        } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaApiKeyRecord>>;
+        /** Update API key metadata. Route: `POST /api-key/update`. */
+        update: (input: AthenaApiKeyUpdateRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaApiKeyRecord>>;
+        /** Delete API key. Route: `POST /api-key/delete`. */
+        delete: (input: AthenaApiKeyDeleteRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAdminSuccessResponse>>;
+        /** List API keys. Route: `GET /api-key/list`. */
+        list: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaApiKeyRecord[]>>;
+        /** Verify an API key. Route: `POST /api-key/verify`. */
+        verify: (input: AthenaApiKeyVerifyRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaApiKeyVerifyResponse>>;
+        /** Delete all expired API keys. Route: `POST /api-key/delete-all-expired-api-keys`. */
+        deleteAllExpired: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaApiKeyDeleteAllExpiredResponse>>;
+    };
+    signIn: {
+        /** Sign in with email and password. Route: `POST /sign-in/email`. */
+        email: AthenaAuthSdkClient['signIn']['email'];
+        /** Sign in with username and password. Route: `POST /sign-in/username`. */
+        username: AthenaAuthSdkClient['signIn']['username'];
+        /** Sign in with social provider. Route: `POST /sign-in/social`. */
+        social: AthenaAuthSdkClient['signIn']['social'];
+    };
+    signUp: {
+        /** Sign up with email/password identity. Route: `POST /sign-up/email`. */
+        email: AthenaAuthSdkClient['signUp']['email'];
+    };
+    /** Organization plugin helper surface. Routes: `/organization/*`. */
+    organization: AthenaAuthOrganizationBindings;
+    callback: {
+        /** OAuth provider callback passthrough. Route: `GET /callback/{provider}`. */
+        provider: (input: AthenaAuthCallbackProviderRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthCallbackProviderResponse>>;
+    };
+}
+interface AthenaAuthSdkClient {
+    baseUrl: string;
+    request: <T = unknown>(input: AthenaAuthRequestInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<T>>;
+    signIn: {
+        email: (input: AthenaEmailSignInRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignInResponse>>;
+        username: (input: AthenaUsernameSignInRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignInResponse>>;
+        social: (input: AthenaSocialSignInRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSocialRedirectResponse | AthenaAuthSignInResponse>>;
+    };
+    signUp: {
+        email: (input: AthenaEmailSignUpRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignInResponse>>;
+    };
+    signOut: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignOutResponse>>;
+    logout: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSignOutResponse>>;
+    getSession: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSessionResponse>>;
+    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>>;
+    revokeSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    clearSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    revokeOtherSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    clearOtherSessions: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    forgetPassword: (input: AthenaForgetPasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    resetPassword: (input: AthenaResetPasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    resolveResetPasswordToken: (input: {
+        token: string;
+        callbackURL?: string;
+    } & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
+        token?: string;
+    }>>;
+    verifyEmail: (input: AthenaVerifyEmailRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
+        user: AthenaAuthUser;
+        status: boolean;
+    }>>;
+    sendVerificationEmail: (input: AthenaSendVerificationEmailRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    changeEmail: (input: AthenaChangeEmailRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthEmailChangeResponse>>;
+    changePassword: (input: AthenaChangePasswordRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<{
+        token?: string | null;
+        user: AthenaAuthUser;
+    }>>;
+    updateUser: (input: AthenaUpdateUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    deleteUser: (input?: AthenaDeleteUserRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaDeleteUserResponse>>;
+    deleteUserCallback: (input?: AthenaDeleteUserCallbackRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaDeleteUserResponse>>;
+    linkSocial: (input: AthenaLinkSocialRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthSocialRedirectResponse>>;
+    listAccounts: (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthLinkedAccount[]>>;
+    unlinkAccount: (input: AthenaUnlinkAccountRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaAuthStatusResponse>>;
+    refreshToken: (input: AthenaOAuthAccountTokenRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaOAuthTokenBundle>>;
+    getAccessToken: (input: AthenaOAuthAccountTokenRequest & AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<AthenaOAuthTokenBundle>>;
+    organization: AthenaAuthOrganizationBindings;
+    auth: AthenaAuthBindings;
+}
+
+type AthenaErrorKind = 'unique_violation' | 'not_found' | 'validation' | 'auth' | 'rate_limit' | 'transient' | 'unknown';
+declare const AthenaErrorKind: {
+    readonly UniqueViolation: "unique_violation";
+    readonly NotFound: "not_found";
+    readonly Validation: "validation";
+    readonly Auth: "auth";
+    readonly RateLimit: "rate_limit";
+    readonly Transient: "transient";
+    readonly Unknown: "unknown";
+};
+type AthenaErrorCode = 'UNIQUE_VIOLATION' | 'NOT_FOUND' | 'VALIDATION_FAILED' | 'AUTH_UNAUTHORIZED' | 'AUTH_FORBIDDEN' | 'RATE_LIMITED' | 'NETWORK_UNAVAILABLE' | 'TRANSIENT_FAILURE' | 'HTTP_FAILURE' | 'UNKNOWN';
+declare const AthenaErrorCode: {
+    readonly UniqueViolation: "UNIQUE_VIOLATION";
+    readonly NotFound: "NOT_FOUND";
+    readonly ValidationFailed: "VALIDATION_FAILED";
+    readonly AuthUnauthorized: "AUTH_UNAUTHORIZED";
+    readonly AuthForbidden: "AUTH_FORBIDDEN";
+    readonly RateLimited: "RATE_LIMITED";
+    readonly NetworkUnavailable: "NETWORK_UNAVAILABLE";
+    readonly TransientFailure: "TRANSIENT_FAILURE";
+    readonly HttpFailure: "HTTP_FAILURE";
+    readonly Unknown: "UNKNOWN";
+};
+type AthenaErrorCategory = 'transport' | 'client' | 'server' | 'database' | 'unknown';
+declare const AthenaErrorCategory: {
+    readonly Transport: "transport";
+    readonly Client: "client";
+    readonly Server: "server";
+    readonly Database: "database";
+    readonly Unknown: "unknown";
+};
+interface AthenaOperationContext {
+    table?: string;
+    operation?: string;
+    identity?: string | Record<string, unknown>;
+}
+interface NormalizedAthenaError {
+    kind: AthenaErrorKind;
+    code: AthenaErrorCode;
+    category: AthenaErrorCategory;
+    retryable: boolean;
+    status?: number;
+    constraint?: string;
+    table?: string;
+    operation?: string;
+    message: string;
+    raw: unknown;
+}
+interface AthenaErrorInput {
+    code: AthenaErrorCode;
+    kind: AthenaErrorKind;
+    category: AthenaErrorCategory;
+    message: string;
+    status?: number;
+    retryable?: boolean;
+    requestId?: string;
+    context?: AthenaOperationContext;
+    raw?: unknown;
+}
+interface UnwrapOptions {
+    allowNull?: boolean;
+    context?: AthenaOperationContext;
+}
+interface UnwrapOneOptions extends UnwrapOptions {
+    requireExactlyOne?: boolean;
+}
+interface IntCoercionOptions {
+    strictBigInt?: boolean;
+    min?: number;
+    max?: number;
+}
+type RetryBackoffStrategy = 'linear' | 'exponential' | ((attempt: number, error: unknown) => number);
+interface RetryConfig {
+    retries: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    backoff?: RetryBackoffStrategy;
+    jitter?: boolean | number;
+    shouldRetry?: (error: unknown, attempt: number) => boolean | Promise<boolean>;
+}
+interface RequireAffectedOptions {
+    min?: number;
+}
+/**
+ * Parses a string-based boolean flag with a deterministic fallback.
+ *
+ * Accepts common truthy/falsey token variants used by env vars and CLI flags.
+ */
+declare function parseBooleanFlag(rawValue: string | undefined, fallback: boolean): boolean;
+declare class AthenaError extends Error {
+    readonly code: AthenaErrorCode;
+    readonly kind: AthenaErrorKind;
+    readonly category: AthenaErrorCategory;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly requestId?: string;
+    readonly context?: AthenaOperationContext;
+    readonly raw?: unknown;
+    constructor(input: AthenaErrorInput);
+}
+/**
+ * Returns `true` when a result is successful (`2xx` status and no `error`).
+ */
+declare function isOk<T>(result: AthenaResult<T>): boolean;
+/**
+ * @deprecated Prefer `result.error` on failed `AthenaResult` values and the
+ * structured fields already attached to thrown SDK errors. This helper is
+ * retained for compatibility with mixed unknown inputs.
+ *
+ * Normalizes any Athena failure shape into a stable, typed error envelope.
+ *
+ * Accepts `AthenaResult`, `AthenaGatewayError`, native `Error`, or unknown values.
+ * Optional `context` can override inferred table/operation metadata for clearer diagnostics.
+ */
+declare function normalizeAthenaError(resultOrError: unknown, context?: AthenaOperationContext): NormalizedAthenaError;
+/**
+ * Unwraps a successful result into a row array.
+ *
+ * - Throws on failed results.
+ * - Converts `null` data to an empty array.
+ * - Wraps scalar data in a single-element array.
+ */
+declare function unwrapRows<T>(result: AthenaResult<T[] | T | null>, options?: UnwrapOptions): T[];
+/**
+ * Unwraps successful result data from `AthenaResult<T | null>`.
+ *
+ * By default, `null` data throws. Pass `{ allowNull: true }` to permit nullable payloads.
+ */
+declare function unwrap<T>(result: AthenaResult<T | null>, options: UnwrapOptions & {
+    allowNull: true;
+}): T | null;
+declare function unwrap<T>(result: AthenaResult<T | null>, options?: UnwrapOptions): T;
+/**
+ * Unwraps the first row from a successful result that may contain arrays/scalars/null.
+ *
+ * - Throws on failed results.
+ * - Throws when no row exists unless `allowNull: true` is provided.
+ * - Optionally enforces exact cardinality via `requireExactlyOne`.
+ */
+declare function unwrapOne<T>(result: AthenaResult<T[] | T | null>, options: UnwrapOneOptions & {
+    allowNull: true;
+}): T | null;
+declare function unwrapOne<T>(result: AthenaResult<T[] | T | null>, options?: UnwrapOneOptions): T;
+/**
+ * Asserts that an Athena result is successful.
+ *
+ * Returns the original result for fluent composition and throws `AthenaGatewayError` on failure.
+ */
+declare function requireSuccess<T>(result: AthenaResult<T>, context?: AthenaOperationContext): AthenaResult<T>;
+/**
+ * Enforces mutation postconditions based on `result.count`.
+ *
+ * - Validates success first.
+ * - Requires a non-null count in the response.
+ * - Validates `count >= min` (default: `1`).
+ *
+ * Useful for guaranteeing that critical writes actually affected rows.
+ */
+declare function requireAffected<T>(result: AthenaResult<T>, options?: RequireAffectedOptions, context?: AthenaOperationContext): number;
+/**
+ * Safely coerces `unknown` values into finite integers.
+ *
+ * Returns `null` when coercion fails or bounds/strict bigint checks are violated.
+ */
+declare function coerceInt(value: unknown, options?: IntCoercionOptions): number | null;
+/**
+ * Strict integer assertion wrapper around `coerceInt`.
+ *
+ * Throws a `TypeError` with the provided label when coercion fails.
+ */
+declare function assertInt(value: unknown, label?: string, options?: IntCoercionOptions): number;
+/**
+ * Retries an async operation with configurable backoff and retry policy.
+ *
+ * `retries` represents additional attempts after the first failure.
+ * By default, transient and rate-limit errors are retried.
+ */
+declare function withRetry<T>(config: RetryConfig, fn: () => Promise<T>): Promise<T>;
+
+type Whitespace = ' ' | '\n' | '\r' | '\t';
+type TrimLeft<TValue extends string> = TValue extends `${Whitespace}${infer TRest}` ? TrimLeft<TRest> : TValue;
+type TrimRight<TValue extends string> = TValue extends `${infer TRest}${Whitespace}` ? TrimRight<TRest> : TValue;
+type Trim<TValue extends string> = TrimLeft<TrimRight<TValue>>;
+type KnownSelectColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
+type HasKnownSelectColumns<Row> = [KnownSelectColumnKey<Row>] extends [never] ? false : string extends KnownSelectColumnKey<Row> ? false : true;
+type HasComplexSelectTokenSyntax<TValue extends string> = TValue extends `${string}(${string}` ? true : TValue extends `${string})${string}` ? true : TValue extends `${string}.${string}` ? true : TValue extends `${string}"${string}` ? true : TValue extends `${string}'${string}` ? true : false;
+type ValidateAliasedBase<Row, TOriginal extends string, TBase extends string> = HasComplexSelectTokenSyntax<Trim<TBase>> extends true ? TOriginal : Trim<TBase> extends KnownSelectColumnKey<Row> ? TOriginal : never;
+type ValidateSelectToken<Row, TToken extends string> = Trim<TToken> extends infer TTrimmed extends string ? TTrimmed extends '' ? never : TTrimmed extends '*' ? TTrimmed : TTrimmed extends `${string}:${infer TBase}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : TTrimmed extends `${infer TBase} as ${string}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : TTrimmed extends `${infer TBase} AS ${string}` ? ValidateAliasedBase<Row, TTrimmed, TBase> : HasComplexSelectTokenSyntax<TTrimmed> extends true ? TTrimmed : TTrimmed extends KnownSelectColumnKey<Row> ? TTrimmed : never : never;
+type ValidateSelectList<Row, TValue extends string> = string extends TValue ? TValue : HasComplexSelectTokenSyntax<TValue> extends true ? TValue : TValue extends `${infer THead},${infer TTail}` ? ValidateSelectToken<Row, THead> extends never ? never : ValidateSelectList<Row, TTail> extends never ? never : TValue : ValidateSelectToken<Row, TValue> extends never ? never : TValue;
+type ValidateSelectArray<Row, TValue extends readonly string[]> = string extends TValue[number] ? TValue : TValue extends readonly [
+    infer THead extends string,
+    ...infer TTail extends readonly string[]
+] ? ValidateSelectToken<Row, THead> extends never ? never : ValidateSelectArray<Row, TTail> extends never ? never : TValue : TValue;
+type AthenaSelectInput = string | string[] | readonly string[];
+type AthenaValidatedSelectInput<Row, TValue extends AthenaSelectInput> = HasKnownSelectColumns<Row> extends true ? TValue extends string ? ValidateSelectList<Row, TValue> : TValue extends readonly string[] ? ValidateSelectArray<Row, TValue> : never : TValue;
+type AthenaTypecheckedColumnKey<Row, TEnabled extends boolean> = TEnabled extends true ? HasKnownSelectColumns<Row> extends true ? KnownSelectColumnKey<Row> : string : string;
+
+type AthenaRowShape$2 = Record<string, AthenaJsonValue | undefined>;
+type AthenaUpsertOptions<Update> = AthenaGatewayCallOptions & {
+    updateBody?: Update;
+    onConflict?: string | string[];
+};
+interface AthenaDbModule<TStrict extends boolean = false> {
+    from<TModel extends AthenaModelTarget>(model: TModel): TableQueryBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>, unknown, TStrict>;
+    from<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update, unknown, TStrict>;
+    select<Row = AthenaRowShape$2>(table: string, options?: AthenaGatewayCallOptions): SelectChain<Row, Row, TStrict>;
+    select(table: string, columns: AthenaSelectInput, options?: AthenaGatewayCallOptions): SelectChain<AthenaRowShape$2, AthenaRowShape$2, TStrict>;
+    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: string, values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row, Row, TStrict>;
+    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: string, values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[], Row, TStrict>;
+    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert, options?: AthenaUpsertOptions<Update>): MutationQuery<Row, Row, TStrict>;
+    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert[], options?: AthenaUpsertOptions<Update>): MutationQuery<Row[], Row, TStrict>;
+    update<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row, TStrict>;
+    delete<Row = AthenaRowShape$2>(table: string, options?: AthenaGatewayCallOptions & {
+        resourceId?: string;
+    }): MutationQuery<Row | null, Row, 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[]>>;
+}
+
+type AthenaStorageTemplateValue = string | number | boolean | null | undefined;
+type AthenaStorageTemplateVars = Record<string, AthenaStorageTemplateValue>;
+type AthenaStorageEnv = Record<string, string | undefined>;
+type AthenaStorageUploadHeaders = ConstructorParameters<typeof Headers>[0];
+type AthenaStoragePrefixPath = string | ((context: AthenaStoragePathContext) => string | null | undefined);
+interface AthenaStoragePathContext {
+    vars: AthenaStorageTemplateVars;
+    env: AthenaStorageEnv;
+    organizationId?: string;
+    organization_id?: string;
+    userId?: string;
+    user_id?: string;
+    resourceId?: string;
+    resource_id?: string;
+}
+interface AthenaStorageFileConfig {
+    /**
+     * Prefix applied by high-level file helpers before storage keys are sent to Athena.
+     * Supports tokens such as `{organization_id}`, `{organizationId}`, `{env.NODE_ENV}`,
+     * and `${ATHENA_STORAGE_PREFIX}`.
+     */
+    prefixPath?: AthenaStoragePrefixPath;
+    vars?: AthenaStorageTemplateVars;
+    env?: AthenaStorageEnv;
+}
+type AthenaStorageUploadSource = Blob | ArrayBuffer | Uint8Array;
+interface AthenaStorageUploadConstraints {
+    maxFiles?: number;
+    allowedExtensions?: readonly string[];
+    extensions?: readonly string[];
+    maxFileSizeMb?: number;
+    maxFileSizeBytes?: number;
+}
+interface AthenaStorageUploadProgress {
+    phase: 'preparing' | 'uploading' | 'complete';
+    fileIndex: number;
+    fileCount: number;
+    fileName: string;
+    loaded: number;
+    total: number;
+    percent: number;
+    aggregateLoaded: number;
+    aggregateTotal: number;
+    aggregatePercent: number;
+}
+type AthenaStorageUploadProgressHandler = (progress: AthenaStorageUploadProgress) => void;
+interface AthenaStorageFileUploadInput extends AthenaStorageUploadConstraints {
+    s3_id: string;
+    bucket?: string;
+    files: AthenaStorageUploadSource | ArrayLike<AthenaStorageUploadSource> | readonly AthenaStorageUploadSource[];
+    storage_key?: string;
+    storageKey?: string;
+    storageKeyTemplate?: string;
+    prefixPath?: AthenaStoragePrefixPath;
+    fileName?: string;
+    name?: string;
+    original_name?: string;
+    resource_id?: string;
+    resourceId?: string;
+    organization_id?: string;
+    organizationId?: string;
+    user_id?: string;
+    userId?: string;
+    mime_type?: string;
+    content_type?: string;
+    public?: boolean;
+    metadata?: Record<string, unknown>;
+    vars?: AthenaStorageTemplateVars;
+    env?: AthenaStorageEnv;
+    uploadHeaders?: AthenaStorageUploadHeaders;
+    onProgress?: AthenaStorageUploadProgressHandler;
+}
+interface AthenaStorageUploadedFile {
+    file: ManagedFileRecord;
+    upload: StorageUploadUrlResponse['upload'];
+    source: AthenaStorageUploadSource;
+    fileName: string;
+    storage_key: string;
+    response: Response;
+}
+interface AthenaStorageFileUploadResult {
+    files: AthenaStorageUploadedFile[];
+    count: number;
+}
+interface AthenaStorageFileListInput extends Omit<ListStorageFilesRequest, 'prefix'> {
+    prefix?: string;
+    prefixPath?: AthenaStoragePrefixPath;
+    vars?: AthenaStorageTemplateVars;
+    env?: AthenaStorageEnv;
+    organization_id?: string;
+    organizationId?: string;
+    user_id?: string;
+    userId?: string;
+    resource_id?: string;
+    resourceId?: string;
+}
+interface AthenaStorageFileDownloadInput extends GetStorageFileUrlQuery {
+    fileId?: string;
+    fileIds?: readonly string[];
+}
+type AthenaStorageFileDeleteInput = string | readonly string[];
+interface AthenaStorageFileModule {
+    upload(input: AthenaStorageFileUploadInput, options?: AthenaStorageCallOptions): Promise<AthenaStorageFileUploadResult>;
+    download(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response>;
+    download(fileIds: readonly string[], query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response[]>;
+    download(input: AthenaStorageFileDownloadInput, options?: AthenaStorageBinaryCallOptions): Promise<Response | Response[]>;
+    list(input: AthenaStorageFileListInput, options?: AthenaStorageCallOptions): Promise<StorageListFilesResponse>;
+    delete(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    delete(fileIds: readonly string[], options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse[]>;
+}
+
+declare const storageSdkManifest: {
+    readonly namespace: "storage";
+    readonly basePath: "/storage";
+    readonly envelopeKinds: {
+        readonly raw: "response body is the payload";
+        readonly athena: "response body is { status, message, data }";
+    };
+    readonly methods: readonly [{
+        readonly name: "listStorageCatalogs";
+        readonly method: "GET";
+        readonly path: "/storage/catalogs";
+        readonly responseEnvelope: "raw";
+        readonly responseType: "{ data: S3CatalogItem[] }";
+    }, {
+        readonly name: "createStorageCatalog";
+        readonly method: "POST";
+        readonly path: "/storage/catalogs";
+        readonly requestType: "CreateStorageCatalogRequest";
+        readonly responseEnvelope: "raw";
+        readonly responseType: "S3CatalogItem";
+    }, {
+        readonly name: "updateStorageCatalog";
+        readonly method: "PATCH";
+        readonly path: "/storage/catalogs/{id}";
+        readonly pathParams: readonly ["id"];
+        readonly requestType: "UpdateStorageCatalogRequest";
+        readonly responseEnvelope: "raw";
+        readonly responseType: "S3CatalogItem";
+    }, {
+        readonly name: "deleteStorageCatalog";
+        readonly method: "DELETE";
+        readonly path: "/storage/catalogs/{id}";
+        readonly pathParams: readonly ["id"];
+        readonly responseEnvelope: "raw";
+        readonly responseType: "{ id: string; deleted: boolean }";
+    }, {
+        readonly name: "listStorageCredentials";
+        readonly method: "GET";
+        readonly path: "/storage/credentials";
+        readonly responseEnvelope: "raw";
+        readonly responseType: "{ data: S3CredentialListItem[] }";
+    }, {
+        readonly name: "createStorageUploadUrl";
+        readonly method: "POST";
+        readonly path: "/storage/files/upload-url";
+        readonly requestType: "CreateStorageUploadUrlRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageUploadUrlResponse";
+    }, {
+        readonly name: "createStorageUploadUrls";
+        readonly method: "POST";
+        readonly path: "/storage/files/upload-urls";
+        readonly requestType: "CreateStorageUploadUrlsRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageBatchUploadUrlResponse";
+    }, {
+        readonly name: "listStorageFiles";
+        readonly method: "POST";
+        readonly path: "/storage/files/list";
+        readonly requestType: "ListStorageFilesRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageListFilesResponse";
+    }, {
+        readonly name: "getStorageFile";
+        readonly method: "GET";
+        readonly path: "/storage/files/{file_id}";
+        readonly pathParams: readonly ["file_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "getStorageFileUrl";
+        readonly method: "GET";
+        readonly path: "/storage/files/{file_id}/url";
+        readonly pathParams: readonly ["file_id"];
+        readonly queryParams: readonly ["purpose"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "PresignedFileUrlResponse";
+    }, {
+        readonly name: "getStorageFileProxy";
+        readonly method: "GET";
+        readonly path: "/storage/files/{file_id}/proxy";
+        readonly pathParams: readonly ["file_id"];
+        readonly queryParams: readonly ["purpose"];
+        readonly responseEnvelope: "raw";
+        readonly responseType: "Response";
+        readonly binary: true;
+    }, {
+        readonly name: "updateStorageFile";
+        readonly method: "PATCH";
+        readonly path: "/storage/files/{file_id}";
+        readonly pathParams: readonly ["file_id"];
+        readonly requestType: "UpdateStorageFileRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "deleteStorageFile";
+        readonly method: "DELETE";
+        readonly path: "/storage/files/{file_id}";
+        readonly pathParams: readonly ["file_id"];
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "setStorageFileVisibility";
+        readonly method: "PATCH";
+        readonly path: "/storage/files/{file_id}/visibility";
+        readonly pathParams: readonly ["file_id"];
+        readonly requestType: "SetStorageFileVisibilityRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFileMutationResponse";
+    }, {
+        readonly name: "deleteStorageFolder";
+        readonly method: "POST";
+        readonly path: "/storage/folders/delete";
+        readonly requestType: "DeleteStorageFolderRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFolderMutationResponse";
+    }, {
+        readonly name: "moveStorageFolder";
+        readonly method: "POST";
+        readonly path: "/storage/folders/move";
+        readonly requestType: "MoveStorageFolderRequest";
+        readonly responseEnvelope: "athena";
+        readonly responseType: "StorageFolderMutationResponse";
+    }];
+};
+interface S3CatalogItem {
+    id: string;
+    name: string;
+    endpoint?: string | null;
+    region?: string | null;
+    bucket: string;
+    provider: string;
+    force_path_style: boolean;
+    default_prefix?: string | null;
+    public_base_url?: string | null;
+    is_active: boolean;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface S3CredentialListItem {
+    id: string;
+    s3_id: string;
+    name: string;
+    endpoint?: string | null;
+    region?: string | null;
+    bucket: string;
+    provider: string;
+    access_key: string;
+    is_active: boolean;
+    created_at: string;
+    rotated_at?: string | null;
+}
+interface ManagedFileRecord {
+    id: string;
+    name: string;
+    original_name?: string | null;
+    file_name?: string | null;
+    url?: string | null;
+    bucket: string;
+    s3_id?: string | null;
+    prefix_path?: string | null;
+    size_bytes?: number | null;
+    mime_type?: string | null;
+    content_type?: string | null;
+    resource_id?: string | null;
+    organization_id?: string | null;
+    created_by_user_id?: string | null;
+    uploaded_by_user_id?: string | null;
+    checksum_sha256?: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+    storage_key: string;
+    extension?: string | null;
+    visibility?: 'private' | 'organization' | 'public';
+    is_public: boolean;
+    status: string;
+    deleted_at?: string | null;
+}
+interface PresignedFileUrlResponse {
+    file_id: string;
+    bucket: string;
+    storage_key: string;
+    purpose: string;
+    url: string;
+    expires_at: string;
+    expires_at_epoch_seconds: number;
+    expires_in: number;
+    cache_hit: boolean;
+    cache_layer: string;
+}
+interface CreateStorageCatalogRequest {
+    name: string;
+    endpoint: string;
+    region: string;
+    bucket: string;
+    provider?: string;
+    force_path_style?: boolean;
+    default_prefix?: string;
+    public_base_url?: string;
+    access_key_id: string;
+    secret_key: string;
+    session_token?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateStorageCatalogRequest {
+    name?: string;
+    endpoint?: string;
+    region?: string;
+    bucket?: string;
+    provider?: string;
+    force_path_style?: boolean;
+    default_prefix?: string | null;
+    public_base_url?: string | null;
+    access_key_id?: string;
+    secret_key?: string;
+    session_token?: string;
+    is_active?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface CreateStorageUploadUrlRequest {
+    s3_id: string;
+    bucket?: string;
+    storage_key: string;
+    name?: string;
+    original_name?: string;
+    resource_id?: string;
+    mime_type?: string;
+    content_type?: string;
+    size_bytes?: number;
+    file_id?: string;
+    public?: boolean;
+    visibility?: 'private' | 'organization' | 'public';
+    metadata?: Record<string, unknown>;
+}
+interface CreateStorageUploadUrlsRequest {
+    files: CreateStorageUploadUrlRequest[];
+}
+interface StorageUploadUrlResponse {
+    file: ManagedFileRecord;
+    upload: PresignedFileUrlResponse;
+}
+interface StorageBatchUploadUrlResponse {
+    files: StorageUploadUrlResponse[];
+}
+interface ListStorageFilesRequest {
+    s3_id: string;
+    prefix: string;
+}
+interface StorageListFilesResponse {
+    files: ManagedFileRecord[];
+    count: number;
+}
+interface UpdateStorageFileRequest {
+    storage_key: string;
+    bucket?: string;
+}
+interface SetStorageFileVisibilityRequest {
+    public?: boolean;
+    visibility?: 'private' | 'organization' | 'public';
+}
+interface DeleteStorageFolderRequest {
+    s3_id: string;
+    prefix: string;
+}
+interface MoveStorageFolderRequest {
+    s3_id: string;
+    from_prefix: string;
+    to_prefix: string;
+}
+interface StorageFileMutationResponse {
+    file: ManagedFileRecord;
+}
+interface StorageFolderMutationResponse {
+    s3_id: string;
+    prefix: string;
+    processed_files: number;
+}
+interface StorageFileMutationManyResponse {
+    files: ManagedFileRecord[];
+    count: number;
+}
+interface StorageFilePermissionRecord {
+    id: string;
+    file_id: string;
+    principal_type: 'user' | 'organization' | 'team' | 'role';
+    principal_id: string;
+    permission: 'read' | 'write' | 'delete' | 'share' | 'owner';
+    granted_by_user_id?: string | null;
+    created_at: string;
+    expires_at?: string | null;
+    revoked_at?: string | null;
+    metadata: Record<string, unknown>;
+}
+interface StoragePermissionListResponse {
+    permissions: StorageFilePermissionRecord[];
+    count: number;
+}
+interface StoragePermissionCheckResponse {
+    allowed: boolean;
+    permission: string;
+}
+interface StorageAuditEventRecord {
+    id: string;
+    operation: string;
+    file_id?: string | null;
+    s3_id?: string | null;
+    bucket?: string | null;
+    storage_key?: string | null;
+    actor_user_id?: string | null;
+    organization_id?: string | null;
+    status: 'success' | 'error';
+    error?: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+}
+interface StorageAuditListResponse {
+    events: StorageAuditEventRecord[];
+    count: number;
+}
+interface ConfirmStorageUploadRequest {
+    size_bytes?: number;
+    content_type?: string;
+    checksum_sha256?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SearchStorageFilesRequest {
+    query?: string;
+    limit?: number;
+}
+interface DeleteManyStorageFilesRequest {
+    file_ids: string[];
+}
+interface UpdateManyStorageFilesRequest {
+    file_ids: string[];
+    storage_key: string;
+    bucket?: string;
+}
+interface SetManyStorageFileVisibilityRequest {
+    file_ids: string[];
+    public?: boolean;
+    visibility?: 'private' | 'organization' | 'public';
+}
+interface CopyStorageFileRequest {
+    storage_key: string;
+    bucket?: string;
+    file_name?: string;
+    visibility?: 'private' | 'organization' | 'public';
+    metadata?: Record<string, unknown>;
+}
+interface ListStorageFoldersRequest {
+    s3_id: string;
+    prefix: string;
+}
+interface TreeStorageFoldersRequest {
+    s3_id: string;
+    prefix: string;
+}
+interface StoragePermissionListRequest {
+    file_id: string;
+}
+interface StoragePermissionGrantRequest {
+    file_id: string;
+    principal_type: 'user' | 'organization' | 'team' | 'role';
+    principal_id: string;
+    permission: 'read' | 'write' | 'delete' | 'share' | 'owner';
+    expires_at?: string;
+    metadata?: Record<string, unknown>;
+}
+interface StoragePermissionRevokeRequest {
+    file_id: string;
+    principal_type: 'user' | 'organization' | 'team' | 'role';
+    principal_id: string;
+    permission: 'read' | 'write' | 'delete' | 'share' | 'owner';
+}
+interface StoragePermissionCheckRequest {
+    file_id: string;
+    permission: 'read' | 'write' | 'delete' | 'share' | 'owner';
+}
+interface StorageMultipartCreateRequest {
+    file_id: string;
+    content_type?: string;
+}
+interface StorageMultipartSignPartRequest {
+    file_id: string;
+    upload_id: string;
+    part_number: number;
+}
+interface StorageMultipartCompletePartInput {
+    part_number: number;
+    etag: string;
+}
+interface StorageMultipartCompleteRequest {
+    file_id: string;
+    upload_id: string;
+    parts: StorageMultipartCompletePartInput[];
+}
+interface StorageMultipartAbortRequest {
+    file_id: string;
+    upload_id: string;
+}
+interface StorageMultipartListPartsRequest {
+    file_id: string;
+    upload_id: string;
+}
+interface StorageObjectFolderCreateRequest {
+    endpoint: string;
+    region: string;
+    access_key_id: string;
+    secret_key: string;
+    bucket: string;
+    prefix: string;
+}
+type StorageObjectFolderDeleteRequest = StorageObjectFolderCreateRequest;
+interface StorageObjectFolderRenameRequest extends Omit<StorageObjectFolderCreateRequest, 'prefix'> {
+    from_prefix: string;
+    to_prefix: string;
+}
+interface StorageObjectBaseRequest {
+    endpoint: string;
+    region: string;
+    access_key_id: string;
+    secret_key: string;
+    bucket: string;
+}
+interface StorageObjectRequest extends StorageObjectBaseRequest {
+    key: string;
+}
+interface StorageObjectCopyRequest extends StorageObjectBaseRequest {
+    source_key: string;
+    destination_key: string;
+    destination_bucket?: string;
+}
+interface StorageObjectPublicUrlRequest extends StorageObjectRequest {
+    public_base_url?: string;
+    force_path_style?: boolean;
+}
+interface StorageListObjectsRequest extends StorageObjectBaseRequest {
+    prefix?: string;
+    delimiter?: string;
+    continuation_token?: string;
+    max_keys?: number;
+}
+interface StorageUpdateObjectRequest extends StorageObjectRequest {
+    acl?: string;
+    content_type?: string;
+    cache_control?: string;
+    content_disposition?: string;
+    content_encoding?: string;
+    content_language?: string;
+    metadata?: Record<string, string>;
+}
+interface StoragePresignUploadRequest extends StorageObjectRequest {
+    content_type?: string;
+}
+type StorageBucketCorsRequest = StorageObjectBaseRequest;
+interface StorageBucketCorsRuleInput {
+    allowed_origins: string[];
+    allowed_methods: string[];
+    allowed_headers?: string[];
+    expose_headers?: string[];
+    max_age_seconds?: number;
+}
+interface StorageSetBucketCorsRequest extends StorageBucketCorsRequest {
+    rules: StorageBucketCorsRuleInput[];
+}
+interface StorageAuditQueryRequest {
+    file_id?: string;
+    limit?: number;
+    offset?: number;
+}
+interface AthenaEnvelope<T> {
+    status: string;
+    message: string;
+    data: T;
+}
+type StorageFileAccessPurpose = 'read' | 'download' | 'stream';
+interface GetStorageFileUrlQuery {
+    purpose?: StorageFileAccessPurpose | (string & {});
+}
+type AthenaStorageErrorHandler = (error: AthenaStorageError) => void | Promise<void>;
+interface AthenaStorageClientConfig extends AthenaStorageFileConfig {
+    onError?: AthenaStorageErrorHandler;
+}
+interface AthenaStorageCallOptions extends AthenaGatewayCallOptions {
+    signal?: AbortSignal;
+    onError?: AthenaStorageErrorHandler;
+}
+type AthenaStorageBinaryCallOptions = AthenaStorageCallOptions;
+type AthenaStorageErrorCode = 'INVALID_URL' | 'NETWORK_ERROR' | 'HTTP_ERROR' | 'INVALID_JSON' | 'INVALID_ATHENA_ENVELOPE' | 'UNKNOWN_ERROR';
+declare const AthenaStorageErrorCode: {
+    readonly InvalidUrl: "INVALID_URL";
+    readonly NetworkError: "NETWORK_ERROR";
+    readonly HttpError: "HTTP_ERROR";
+    readonly InvalidJson: "INVALID_JSON";
+    readonly InvalidAthenaEnvelope: "INVALID_ATHENA_ENVELOPE";
+    readonly UnknownError: "UNKNOWN_ERROR";
+};
+interface AthenaStorageErrorDetails {
+    code: AthenaStorageErrorCode;
+    athenaCode: AthenaErrorCode;
+    kind: AthenaErrorKind;
+    category: AthenaErrorCategory;
+    retryable: boolean;
+    message: string;
+    status: number;
+    endpoint: AthenaGatewayEndpointPath;
+    method: AthenaGatewayMethod;
+    requestId?: string;
+    hint?: string;
+    cause?: string;
+    raw: unknown;
+}
+interface AthenaStorageErrorInput {
+    code: AthenaStorageErrorCode;
+    message: string;
+    status: number;
+    endpoint: AthenaGatewayEndpointPath;
+    method: AthenaGatewayMethod;
+    raw?: unknown;
+    requestId?: string;
+    hint?: string;
+    cause?: unknown;
+}
+declare class AthenaStorageError extends Error {
+    readonly code: AthenaStorageErrorCode;
+    readonly athenaCode: AthenaErrorCode;
+    readonly kind: AthenaErrorKind;
+    readonly category: AthenaErrorCategory;
+    readonly retryable: boolean;
+    readonly status: number;
+    readonly endpoint: AthenaGatewayEndpointPath;
+    readonly method: AthenaGatewayMethod;
+    readonly requestId?: string;
+    readonly hint?: string;
+    readonly causeDetail?: string;
+    readonly raw: unknown;
+    readonly normalized: NormalizedAthenaError;
+    readonly __athenaNormalizedError: NormalizedAthenaError;
+    constructor(input: AthenaStorageErrorInput);
+    toDetails(): AthenaStorageErrorDetails;
+}
+interface AthenaStorageBaseModule {
+    listStorageCatalogs(options?: AthenaStorageCallOptions): Promise<{
+        data: S3CatalogItem[];
+    }>;
+    createStorageCatalog(input: CreateStorageCatalogRequest, options?: AthenaStorageCallOptions): Promise<S3CatalogItem>;
+    updateStorageCatalog(id: string, input: UpdateStorageCatalogRequest, options?: AthenaStorageCallOptions): Promise<S3CatalogItem>;
+    deleteStorageCatalog(id: string, options?: AthenaStorageCallOptions): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+    listStorageCredentials(options?: AthenaStorageCallOptions): Promise<{
+        data: S3CredentialListItem[];
+    }>;
+    createStorageUploadUrl(input: CreateStorageUploadUrlRequest, options?: AthenaStorageCallOptions): Promise<StorageUploadUrlResponse>;
+    createStorageUploadUrls(input: CreateStorageUploadUrlsRequest, options?: AthenaStorageCallOptions): Promise<StorageBatchUploadUrlResponse>;
+    listStorageFiles(input: ListStorageFilesRequest, options?: AthenaStorageCallOptions): Promise<StorageListFilesResponse>;
+    getStorageFile(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    getStorageFileUrl(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageCallOptions): Promise<PresignedFileUrlResponse>;
+    getStorageFileProxy(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response>;
+    updateStorageFile(fileId: string, input: UpdateStorageFileRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    deleteStorageFile(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    setStorageFileVisibility(fileId: string, input: SetStorageFileVisibilityRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    deleteStorageFolder(input: DeleteStorageFolderRequest, options?: AthenaStorageCallOptions): Promise<StorageFolderMutationResponse>;
+    moveStorageFolder(input: MoveStorageFolderRequest, options?: AthenaStorageCallOptions): Promise<StorageFolderMutationResponse>;
+}
+type AthenaStoragePutBody = Blob | ArrayBuffer | Uint8Array | ReadableStream<Uint8Array>;
+interface AthenaStoragePutOptions {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+interface AthenaStorageManagedUpload extends PresignedFileUrlResponse {
+    method: 'PUT';
+    headers: Record<string, string>;
+    expiresAt: string;
+    put(body: AthenaStoragePutBody, options?: AthenaStoragePutOptions): Promise<Response>;
+}
+interface StorageUploadUrlResponseWithPut extends Omit<StorageUploadUrlResponse, 'upload'> {
+    upload: AthenaStorageManagedUpload;
+}
+interface StorageBatchUploadUrlResponseWithPut {
+    files: StorageUploadUrlResponseWithPut[];
+}
+interface AthenaStorageFileUploadRequest {
+    s3_id?: string;
+    s3Id?: string;
+    bucket?: string;
+    storage_key?: string;
+    storageKey?: string;
+    name?: string;
+    fileName?: string;
+    original_name?: string;
+    originalName?: string;
+    resource_id?: string;
+    resourceId?: string;
+    mime_type?: string;
+    mimeType?: string;
+    content_type?: string;
+    contentType?: string;
+    size_bytes?: number;
+    sizeBytes?: number;
+    file_id?: string;
+    fileId?: string;
+    public?: boolean;
+    visibility?: 'private' | 'organization' | 'public';
+    metadata?: Record<string, unknown>;
+}
+interface AthenaStorageFileUploadManyRequest {
+    files: AthenaStorageFileUploadRequest[];
+}
+interface AthenaStorageFileNamespace extends AthenaStorageFileModule {
+    upload(input: AthenaStorageFileUploadRequest, options?: AthenaStorageCallOptions): Promise<StorageUploadUrlResponseWithPut>;
+    upload(input: Parameters<AthenaStorageFileModule['upload']>[0], options?: AthenaStorageCallOptions): ReturnType<AthenaStorageFileModule['upload']>;
+    uploadMany(input: AthenaStorageFileUploadManyRequest, options?: AthenaStorageCallOptions): Promise<StorageBatchUploadUrlResponseWithPut>;
+    confirmUpload(fileId: string, input?: ConfirmStorageUploadRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    uploadBinary(fileId: string, body: AthenaStoragePutBody, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    search(input: SearchStorageFilesRequest, options?: AthenaStorageCallOptions): Promise<StorageListFilesResponse>;
+    get(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    update(fileId: string, input: UpdateStorageFileRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    deleteMany(input: DeleteManyStorageFilesRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationManyResponse>;
+    updateMany(input: UpdateManyStorageFilesRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationManyResponse>;
+    restore(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    purge(fileId: string, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    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>>;
+    proxy(fileId: string, query?: GetStorageFileUrlQuery, options?: AthenaStorageBinaryCallOptions): Promise<Response>;
+    visibility: {
+        set(fileId: string, input: SetStorageFileVisibilityRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+        setMany(input: SetManyStorageFileVisibilityRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationManyResponse>;
+    };
+}
+interface AthenaStorageCredentialsNamespace {
+    list(options?: AthenaStorageCallOptions): Promise<{
+        data: S3CredentialListItem[];
+    }>;
+}
+interface AthenaStorageCatalogNamespace {
+    list(options?: AthenaStorageCallOptions): Promise<{
+        data: S3CatalogItem[];
+    }>;
+    create(input: CreateStorageCatalogRequest, options?: AthenaStorageCallOptions): Promise<S3CatalogItem>;
+    update(id: string, input: UpdateStorageCatalogRequest, options?: AthenaStorageCallOptions): Promise<S3CatalogItem>;
+    delete(id: string, options?: AthenaStorageCallOptions): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
+}
+interface AthenaStorageFolderNamespace {
+    list(input: ListStorageFoldersRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    tree(input: TreeStorageFoldersRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    delete(input: DeleteStorageFolderRequest, options?: AthenaStorageCallOptions): Promise<StorageFolderMutationResponse>;
+    move(input: MoveStorageFolderRequest, options?: AthenaStorageCallOptions): Promise<StorageFolderMutationResponse>;
+}
+interface AthenaStoragePermissionNamespace {
+    list(input: StoragePermissionListRequest, options?: AthenaStorageCallOptions): Promise<StoragePermissionListResponse>;
+    grant(input: StoragePermissionGrantRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    revoke(input: StoragePermissionRevokeRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    check(input: StoragePermissionCheckRequest, options?: AthenaStorageCallOptions): Promise<StoragePermissionCheckResponse>;
+}
+interface AthenaStorageObjectFolderNamespace {
+    create(input: StorageObjectFolderCreateRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    delete(input: StorageObjectFolderDeleteRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    rename(input: StorageObjectFolderRenameRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+}
+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>>;
+    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>>;
+    folder: AthenaStorageObjectFolderNamespace;
+}
+interface AthenaStorageBucketCorsNamespace {
+    get(input: StorageBucketCorsRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    set(input: StorageSetBucketCorsRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    delete(input: StorageBucketCorsRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+}
+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>>;
+    cors: AthenaStorageBucketCorsNamespace;
+}
+interface AthenaStorageMultipartNamespace {
+    create(input: StorageMultipartCreateRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    signPart(input: StorageMultipartSignPartRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    complete(input: StorageMultipartCompleteRequest, options?: AthenaStorageCallOptions): Promise<StorageFileMutationResponse>;
+    abort(input: StorageMultipartAbortRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+    listParts(input: StorageMultipartListPartsRequest, options?: AthenaStorageCallOptions): Promise<Record<string, unknown>>;
+}
+interface AthenaStorageAuditNamespace {
+    list(input: StorageAuditQueryRequest, options?: AthenaStorageCallOptions): Promise<StorageAuditListResponse>;
+}
+interface AthenaStorageModule extends AthenaStorageBaseModule {
+    credentials: AthenaStorageCredentialsNamespace;
+    catalog: AthenaStorageCatalogNamespace;
+    file: AthenaStorageFileNamespace;
+    folder: AthenaStorageFolderNamespace;
+    permission: AthenaStoragePermissionNamespace;
+    object: AthenaStorageObjectNamespace;
+    bucket: AthenaStorageBucketNamespace;
+    multipart: AthenaStorageMultipartNamespace;
+    audit: AthenaStorageAuditNamespace;
+    delete: AthenaStorageFileModule['delete'];
+}
+declare function createAthenaStorageError(input: AthenaStorageErrorInput): AthenaStorageError;
+
+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>;
+type AthenaFilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'contains' | 'containedBy';
+type AthenaWherePrimitive = AthenaConditionValue;
+type AthenaWhereOperatorInput = {
+    eq?: AthenaConditionValue;
+    neq?: AthenaConditionValue;
+    gt?: AthenaConditionValue;
+    gte?: AthenaConditionValue;
+    lt?: AthenaConditionValue;
+    lte?: AthenaConditionValue;
+    like?: AthenaConditionValue;
+    ilike?: AthenaConditionValue;
+    is?: AthenaConditionValue;
+    in?: AthenaConditionArrayValue;
+    contains?: AthenaConditionArrayValue;
+    containedBy?: AthenaConditionArrayValue;
+};
+type AthenaWhereColumnInput<Row = AthenaRowShape$1> = Partial<Record<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereOperatorInput>>;
+type AthenaBooleanSafeOperator = Exclude<AthenaFilterOperator, 'in' | 'contains' | 'containedBy'>;
+type AthenaWhereBooleanSafeOperatorInput = Partial<Record<AthenaBooleanSafeOperator, AthenaConditionValue>>;
+type AthenaWhereBooleanNotOperatorInput = {
+    [K in AthenaBooleanSafeOperator]: {
+        [P in K]: AthenaConditionValue;
+    } & Partial<Record<Exclude<AthenaBooleanSafeOperator, K>, never>>;
+}[AthenaBooleanSafeOperator];
+type AthenaStrictBooleanOperand<Keys extends string, Value> = {
+    [K in Keys]: {
+        [P in K]: Value;
+    } & Partial<Record<Exclude<Keys, K>, never>>;
+}[Keys];
+type AthenaNonEmptyArray<T> = [T, ...T[]];
+type AthenaWhereBooleanOperand<Row = AthenaRowShape$1> = string extends ResolvedFilterColumnKey$1<Row> ? AthenaWhereColumnInput<Row> : AthenaStrictBooleanOperand<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereBooleanSafeOperatorInput>;
+type AthenaWhereNotOperand<Row = AthenaRowShape$1> = string extends ResolvedFilterColumnKey$1<Row> ? AthenaWhereColumnInput<Row> : AthenaStrictBooleanOperand<ResolvedFilterColumnKey$1<Row>, AthenaWherePrimitive | AthenaWhereBooleanNotOperatorInput>;
+type AthenaWhere<Row = AthenaRowShape$1> = AthenaWhereColumnInput<Row> & {
+    or?: string extends ResolvedFilterColumnKey$1<Row> ? Array<AthenaWhereColumnInput<Row>> : AthenaNonEmptyArray<AthenaWhereBooleanOperand<Row>>;
+    not?: AthenaWhereNotOperand<Row>;
+};
+interface AthenaRelationSelectNode<TSelect extends AthenaSelectShape = AthenaSelectShape> {
+    select: TSelect;
+    as?: string;
+    via?: string;
+    schema?: string;
+}
+type AthenaSelectShape = Record<string, true | AthenaRelationSelectNode<AthenaSelectShape>>;
+type AthenaAllowedRelationSelectNodeKey = 'select' | 'as' | 'via' | 'schema';
+type AthenaValidatedRelationSelectNode<TNode> = TNode extends {
+    select: infer TChild;
+} ? Exclude<keyof TNode, AthenaAllowedRelationSelectNodeKey> extends never ? TNode extends {
+    schema: string;
+    via: string;
+} ? never : TChild extends Record<string, unknown> ? {
+    [K in keyof TNode]: K extends 'select' ? AthenaValidatedSelectShape<TChild> : K extends AthenaAllowedRelationSelectNodeKey ? TNode[K] : never;
+} : never : never : never;
+type AthenaValidatedSelectShape<TSelect> = {
+    [K in keyof TSelect]: TSelect[K] extends true ? true : AthenaValidatedRelationSelectNode<TSelect[K]>;
+};
+type GenericRegistryDef = RegistryDef<Record<string, DatabaseDef<Record<string, SchemaDef<Record<string, AnyModelDef>>>>>>;
+type AthenaOrderByDirectionInput = 'asc' | 'desc' | 'ascending' | 'descending' | boolean | {
+    ascending?: boolean;
+};
+type AthenaOrderBy<Row = AthenaRowShape$1> = {
+    column: ResolvedFilterColumnKey$1<Row>;
+    ascending?: boolean;
+} | Partial<Record<ResolvedFilterColumnKey$1<Row>, AthenaOrderByDirectionInput>>;
+interface AthenaFindManyOptions<Row = AthenaRowShape$1, TSelect extends AthenaSelectShape = AthenaSelectShape> {
+    select: TSelect;
+    where?: AthenaWhere<Row>;
+    orderBy?: AthenaOrderBy<Row>;
+    limit?: number;
+}
+type AthenaModelContext<TRegistry extends GenericRegistryDef = GenericRegistryDef, TDatabase extends string = string, TSchema extends string = string, TModel extends AnyModelDef = AnyModelDef> = {
+    registry: TRegistry;
+    database: TDatabase;
+    schema: TSchema;
+    model: TModel;
+};
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type ContextRegistry<TContext> = TContext extends AthenaModelContext<infer TRegistry, string, string, AnyModelDef> ? TRegistry : never;
+type ContextDatabase<TContext> = TContext extends AthenaModelContext<GenericRegistryDef, infer TDatabase, string, AnyModelDef> ? TDatabase : never;
+type ContextModel<TContext> = TContext extends AthenaModelContext<GenericRegistryDef, string, string, infer TModel> ? TModel : never;
+type ModelMetaOf<TContext> = ContextModel<TContext> extends ModelDef<unknown, unknown, unknown, infer TMeta> ? TMeta : never;
+type ModelRelationsOf<TContext> = NonNullable<ModelMetaOf<TContext>['relations']>;
+type SelectedResultKey<TKey extends string, TValue> = TValue extends {
+    as: infer TAlias extends string;
+} ? TAlias : TKey;
+type ScalarSelectionResult<Row, TSelect extends AthenaSelectShape> = {
+    [TKey in Extract<keyof TSelect, string> as TSelect[TKey] extends true ? TKey : never]-?: TKey extends keyof NonNullable<Row> ? NonNullable<Row>[TKey] : unknown;
+};
+type RelationByKey<TContext, TKey extends string> = TKey extends keyof ModelRelationsOf<TContext> ? ModelRelationsOf<TContext>[TKey] : never;
+type RelationByVia<TContext, TVia extends string> = {
+    [TKey in keyof ModelRelationsOf<TContext>]: ModelRelationsOf<TContext>[TKey] extends infer TRelation ? TRelation extends ModelRelationMetadata ? TVia extends TRelation['sourceColumns'][number] ? TRelation : never : never : never;
+}[keyof ModelRelationsOf<TContext>];
+type ResolvedRelation<TContext, TKey extends string, TValue> = RelationByKey<TContext, TKey> extends never ? TValue extends {
+    via: infer TVia extends string;
+} ? RelationByVia<TContext, TVia> : never : RelationByKey<TContext, TKey>;
+type TargetDatabaseName<TContext, TRelation extends ModelRelationMetadata> = TRelation['targetDatabase'] extends string ? TRelation['targetDatabase'] : ContextDatabase<TContext>;
+type ResolveTargetModel<TContext, TRelation extends ModelRelationMetadata> = ContextRegistry<TContext> extends infer TRegistry ? TRegistry extends GenericRegistryDef ? TargetDatabaseName<TContext, TRelation> extends keyof TRegistry & string ? TRelation['targetSchema'] extends keyof TRegistry[TargetDatabaseName<TContext, TRelation>]['schemas'] & string ? TRelation['targetModel'] extends keyof TRegistry[TargetDatabaseName<TContext, TRelation>]['schemas'][TRelation['targetSchema']]['models'] & string ? TRegistry[TargetDatabaseName<TContext, TRelation>]['schemas'][TRelation['targetSchema']]['models'][TRelation['targetModel']] : never : never : never : never : never;
+type RelationResultValue<TRelation extends ModelRelationMetadata, TValue, TContext> = TValue extends AthenaRelationSelectNode<infer TChildSelect> ? ResolveTargetModel<TContext, TRelation> extends infer TTargetModel ? TTargetModel extends AnyModelDef ? TRelation['kind'] extends 'one-to-many' | 'many-to-many' ? Array<AthenaFindManyResult<RowOf<TTargetModel>, TChildSelect, AthenaModelContext<ContextRegistry<TContext>, TargetDatabaseName<TContext, TRelation>, TRelation['targetSchema'], TTargetModel>>> : AthenaFindManyResult<RowOf<TTargetModel>, TChildSelect, AthenaModelContext<ContextRegistry<TContext>, TargetDatabaseName<TContext, TRelation>, TRelation['targetSchema'], TTargetModel>> | null : unknown : unknown : never;
+type RelationSelectionResult<TContext, TSelect extends AthenaSelectShape> = {
+    [TKey in Extract<keyof TSelect, string> as TSelect[TKey] extends AthenaRelationSelectNode<AthenaSelectShape> ? SelectedResultKey<TKey, TSelect[TKey]> : never]-?: ResolvedRelation<TContext, TKey, TSelect[TKey]> extends infer TRelation ? TRelation extends ModelRelationMetadata ? RelationResultValue<TRelation, TSelect[TKey], TContext> : unknown : unknown;
+};
+type AthenaFindManyResult<Row, TSelect extends AthenaSelectShape, TContext = unknown> = Simplify<ScalarSelectionResult<Row, TSelect> & RelationSelectionResult<TContext, TSelect>>;
+
+type AthenaFindManyAstPayload<Row, TSelect extends AthenaSelectShape> = {
+    table_name: string;
+    select: TSelect;
+    where?: AthenaWhere<Row>;
+    orderBy?: AthenaOrderBy<Row>;
+    limit?: number;
+};
+
+interface AthenaTableBuilderStateAst {
+    conditions: AthenaGatewayCondition[];
+    limit?: number;
+    offset?: number;
+    order?: AthenaSortBy;
+    currentPage?: number;
+    pageSize?: number;
+    totalPages?: number;
+}
+interface AthenaRpcBuilderStateAst {
+    filters: AthenaRpcFilter[];
+    limit?: number;
+    offset?: number;
+    order?: {
+        column: string;
+        ascending?: boolean;
+    };
+}
+interface AthenaDebugAstBase<TKind extends string> {
+    version: 1;
+    kind: TKind;
+}
+type AthenaSelectDebugTransport = {
+    mode: 'compiled-fetch' | 'structured-fetch';
+    endpoint: '/gateway/fetch';
+    payload: AthenaFetchPayload;
+} | {
+    mode: 'typed-query';
+    endpoint: '/gateway/query';
+    payload: {
+        query: string;
+    };
+};
+interface AthenaSelectDebugAst extends AthenaDebugAstBase<'select'> {
+    tableName: string;
+    input: {
+        columns: string | string[];
+        state: AthenaTableBuilderStateAst;
+    };
+    transport: AthenaSelectDebugTransport;
+}
+type AthenaFindManyDebugTransport<Row = Record<string, unknown>, TSelect extends AthenaSelectShape = AthenaSelectShape> = {
+    mode: 'direct-ast-fetch';
+    endpoint: '/gateway/fetch';
+    payload: AthenaFindManyAstPayload<Row, TSelect>;
+} | {
+    mode: 'compiled-fetch' | 'structured-fetch';
+    endpoint: '/gateway/fetch';
+    payload: AthenaFetchPayload;
+} | {
+    mode: 'compiled-query';
+    endpoint: '/gateway/query';
+    payload: {
+        query: string;
+    };
+};
+interface AthenaFindManyDebugAst<Row = Record<string, unknown>, TSelect extends AthenaSelectShape = AthenaSelectShape> extends AthenaDebugAstBase<'findMany'> {
+    tableName: string;
+    input: {
+        select: AthenaValidatedSelectShape<TSelect>;
+        where?: AthenaWhere<Row>;
+        orderBy?: AthenaOrderBy<Row>;
+        limit?: number;
+    };
+    compiled: {
+        columns: string;
+        baseState: AthenaTableBuilderStateAst;
+        executionState: AthenaTableBuilderStateAst;
+    };
+    transport: AthenaFindManyDebugTransport<Row, TSelect>;
+}
+interface AthenaInsertDebugAst extends AthenaDebugAstBase<'insert'> {
+    tableName: string;
+    input: {
+        values: AthenaInsertPayload['insert_body'];
+        returning?: AthenaInsertPayload['columns'];
+        count?: AthenaInsertPayload['count'];
+        head?: boolean;
+        defaultToNull?: boolean;
+    };
+    transport: {
+        mode: 'insert';
+        endpoint: '/gateway/insert';
+        payload: AthenaInsertPayload;
+    };
+}
+interface AthenaUpsertDebugAst extends AthenaDebugAstBase<'upsert'> {
+    tableName: string;
+    input: {
+        values: AthenaInsertPayload['insert_body'];
+        updateBody?: AthenaInsertPayload['update_body'];
+        onConflict?: AthenaInsertPayload['on_conflict'];
+        returning?: AthenaInsertPayload['columns'];
+        count?: AthenaInsertPayload['count'];
+        head?: boolean;
+        defaultToNull?: boolean;
+    };
+    transport: {
+        mode: 'upsert';
+        endpoint: '/gateway/insert';
+        payload: AthenaInsertPayload;
+    };
+}
+interface AthenaUpdateDebugAst extends AthenaDebugAstBase<'update'> {
+    tableName: string;
+    input: {
+        values: AthenaUpdatePayload['set'];
+        state: AthenaTableBuilderStateAst;
+        returning?: AthenaUpdatePayload['columns'];
+    };
+    transport: {
+        mode: 'update';
+        endpoint: '/gateway/update';
+        payload: AthenaUpdatePayload;
+    };
+}
+interface AthenaDeleteDebugAst extends AthenaDebugAstBase<'delete'> {
+    tableName: string;
+    input: {
+        resourceId?: AthenaDeletePayload['resource_id'];
+        state: AthenaTableBuilderStateAst;
+        returning?: AthenaDeletePayload['columns'];
+    };
+    transport: {
+        mode: 'delete';
+        endpoint: '/gateway/delete';
+        payload: AthenaDeletePayload;
+    };
+}
+interface AthenaRpcDebugAst extends AthenaDebugAstBase<'rpc'> {
+    functionName: string;
+    input: {
+        args?: AthenaJsonObject;
+        select?: string | string[];
+        state: AthenaRpcBuilderStateAst;
+    };
+    transport: {
+        mode: 'rpc-post' | 'rpc-get';
+        endpoint: '/gateway/rpc' | `/rpc/${string}`;
+        payload: AthenaRpcPayload;
+    };
+}
+interface AthenaRawQueryDebugAst extends AthenaDebugAstBase<'query'> {
+    input: {
+        query: string;
+    };
+    transport: {
+        mode: 'raw-query';
+        endpoint: '/gateway/query';
+        payload: {
+            query: string;
+        };
+    };
+}
+type AthenaQueryDebugAst = AthenaSelectDebugAst | AthenaFindManyDebugAst | AthenaInsertDebugAst | AthenaUpsertDebugAst | AthenaUpdateDebugAst | AthenaDeleteDebugAst | AthenaRpcDebugAst | AthenaRawQueryDebugAst;
+declare function getAthenaDebugAst(value: unknown): AthenaQueryDebugAst | null;
+
+interface AthenaResult<T> {
+    data: T | null;
+    error: AthenaResultError | null;
+    statusText?: string | null;
+    /**
+     * @deprecated Prefer `error?.gatewayCode`, `error?.hint`, and related fields on `error`.
+     */
+    errorDetails?: AthenaGatewayErrorDetails | null;
+    status: number;
+    count?: number | null;
+    raw: unknown;
+}
+interface AthenaResultError {
+    message: string;
+    code: string | null;
+    athenaCode: NormalizedAthenaError['code'];
+    gatewayCode?: AthenaGatewayErrorDetails['code'] | null;
+    kind: NormalizedAthenaError['kind'];
+    category: NormalizedAthenaError['category'];
+    retryable: boolean;
+    details: unknown | null;
+    hint: string | null;
+    status: number;
+    statusText: string | null;
+    constraint?: string;
+    table?: string;
+    operation?: string;
+    endpoint?: AthenaGatewayErrorDetails['endpoint'];
+    method?: AthenaGatewayErrorDetails['method'];
+    requestId?: string;
+    cause?: string;
+    raw: unknown;
+}
+interface AthenaClientExperimentalOptions {
+    /**
+     * @deprecated Failed `AthenaResult` values now include normalized structured `error`
+     * envelopes by default. This flag is retained as a no-op compatibility switch.
+     */
+    enableErrorNormalization?: boolean;
+    /**
+     * Retry retryable read failures (`select`, `findMany`, `query`) with a fixed internal policy.
+     *
+     * Applies two additional attempts with exponential backoff and jitter.
+     */
+    retryReads?: boolean;
+    /**
+     * Emit execution diagnostics for every query/mutation/RPC invocation.
+     * Includes payload, synthesized SQL, full outcome, and best-effort callsite metadata.
+     */
+    traceQueries?: boolean | AthenaQueryTraceOptions;
+    /**
+     * Build and attach a normalized operation AST for runtime debugging.
+     *
+     * When enabled, successful Athena results expose a non-enumerable debug AST
+     * that can be read with `getAthenaDebugAst(...)`. If tracing is also enabled,
+     * the same AST is included on emitted trace events.
+     */
+    debugAst?: boolean;
+    /**
+     * Compile-time opt-in for validating simple `select(...)`, `order(...)`, and
+     * RPC filter column names against known row keys.
+     *
+     * This flag is type-only. It does not change runtime request behavior.
+     */
+    typecheckColumns?: boolean;
+    /**
+     * Send the original `findMany(...)` AST body for clean object-select reads.
+     * This requires gateway support and falls back to legacy compiled transport
+     * when a chain carries filter/pagination state that the AST payload cannot
+     * represent losslessly yet.
+     */
+    findManyAst?: boolean;
+    /**
+     * Expose the experimental `client.storage.*` bindings for Athena storage APIs.
+     */
+    athenaStorageBackend?: boolean;
+    /**
+     * Optional storage SDK runtime hooks. Only used when `athenaStorageBackend` is enabled.
+     */
+    storage?: AthenaStorageClientConfig;
+}
+interface AthenaQueryTraceOptions {
+    /**
+     * Custom sink for trace events. Defaults to console.info.
+     */
+    logger?: (event: AthenaQueryTraceEvent) => void;
+}
+interface AthenaQueryTraceCallsite {
+    filePath: string;
+    fileName: string;
+    line: number;
+    column: number;
+    frame?: string;
+    functionName?: string;
+}
+interface AthenaQueryTraceEvent {
+    timestamp: string;
+    durationMs: number;
+    operation: 'select' | 'insert' | 'upsert' | 'update' | 'delete' | 'rpc' | 'query';
+    endpoint: '/gateway/fetch' | '/gateway/insert' | '/gateway/update' | '/gateway/delete' | '/gateway/rpc' | '/gateway/query' | `/rpc/${string}`;
+    table?: string;
+    functionName?: string;
+    sql: string;
+    payload: unknown;
+    ast?: AthenaQueryDebugAst;
+    options?: AthenaGatewayCallOptions | AthenaRpcCallOptions;
+    callsite: AthenaQueryTraceCallsite | null;
+    outcome?: {
+        status: number;
+        error: AthenaResultError | null;
+        errorDetails?: AthenaGatewayErrorDetails | null;
+        count?: number | null;
+        data: unknown;
+        raw: unknown;
+    };
+    thrownError?: unknown;
+}
+type MutationSingleResult<Result> = Result extends Array<infer Item> ? Item | null : Result | null;
+type MutationResultRow<Result> = Result extends Array<infer Item> ? Item : Result;
+type AthenaRowShape = Record<string, AthenaJsonValue | undefined>;
+type FilterColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
+type ResolvedFilterColumnKey<Row> = [FilterColumnKey<Row>] extends [never] ? string : FilterColumnKey<Row>;
+type SelectColumnsFor<Row, TStrict extends boolean, TValue extends AthenaSelectInput> = TStrict extends true ? AthenaValidatedSelectInput<Row, TValue> : TValue;
+interface MutationQuery<Result, Row = MutationResultRow<Result>, TStrict extends boolean = false> extends PromiseLike<AthenaResult<Result>> {
+    select<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    returning<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    single<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
+    maybeSingle<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
+    then<TResult1 = AthenaResult<Result>, TResult2 = never>(onfulfilled?: ((value: AthenaResult<Result>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<AthenaResult<Result> | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<AthenaResult<Result>>;
+}
+interface OrderOptions {
+    ascending?: boolean;
+}
+/** Shared filter chain - supports eq, limit, etc. in any order relative to select/update */
+interface FilterChain<Self, Row> {
+    eq(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    eqCast(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue, cast: AthenaConditionCastType): Self;
+    eqUuid(column: ResolvedFilterColumnKey<Row>, value: string): Self;
+    match(filters: Partial<Record<ResolvedFilterColumnKey<Row>, AthenaConditionValue>>): Self;
+    range(from: number, to: number): Self;
+    limit(count: number): Self;
+    offset(count: number): Self;
+    currentPage(value: number): Self;
+    pageSize(value: number): Self;
+    totalPages(value: number): Self;
+    order(column: ResolvedFilterColumnKey<Row>, options?: OrderOptions): Self;
+    gt(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    gte(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    lt(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    lte(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    neq(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    like(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    ilike(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    is(column: ResolvedFilterColumnKey<Row>, value: AthenaConditionValue): Self;
+    in(column: ResolvedFilterColumnKey<Row>, values: AthenaConditionArrayValue): Self;
+    contains(column: ResolvedFilterColumnKey<Row>, values: AthenaConditionArrayValue): Self;
+    containedBy(column: ResolvedFilterColumnKey<Row>, values: AthenaConditionArrayValue): Self;
+    not(columnOrExpression: ResolvedFilterColumnKey<Row> | string, operator?: AthenaConditionOperator, value?: AthenaConditionValue): Self;
+    or(expression: string): Self;
+}
+/** Chain returned by select() - supports filters and single/maybeSingle before execution */
+interface SelectChain<Row, SelectedRow = Row, TStrict extends boolean = false> extends FilterChain<SelectChain<Row, SelectedRow, TStrict>, Row>, PromiseLike<AthenaResult<SelectedRow[]>> {
+    single<T = SelectedRow, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = SelectedRow, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+}
+/** Chain returned by update() - supports filters before execution, plus select/returning */
+interface UpdateChain<Row, TStrict extends boolean = false> extends FilterChain<UpdateChain<Row, TStrict>, Row>, MutationQuery<Row[], Row, TStrict> {
+}
+interface RpcFilterChain<Self, Row, TStrict extends boolean = false> {
+    eq(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    neq(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    gt(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    gte(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    lt(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    lte(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    like(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    ilike(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    is(column: AthenaTypecheckedColumnKey<Row, TStrict>, value: AthenaConditionValue): Self;
+    in(column: AthenaTypecheckedColumnKey<Row, TStrict>, values: AthenaConditionArrayValue): Self;
+}
+interface RpcOrderOptions {
+    ascending?: boolean;
+}
+interface RpcQueryBuilder<Row, TStrict extends boolean = false> extends RpcFilterChain<RpcQueryBuilder<Row, TStrict>, Row, TStrict>, PromiseLike<AthenaResult<Row[]>> {
+    select<const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<Row[]>>;
+    single<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    order(column: AthenaTypecheckedColumnKey<Row, TStrict>, options?: RpcOrderOptions): RpcQueryBuilder<Row, TStrict>;
+    limit(count: number): RpcQueryBuilder<Row, TStrict>;
+    offset(count: number): RpcQueryBuilder<Row, TStrict>;
+    range(from: number, to: number): RpcQueryBuilder<Row, TStrict>;
+}
+interface AthenaFromOptions {
+    schema?: string;
+}
+interface TableQueryBuilder<Row, Insert = Partial<Row>, Update = Partial<Insert>, TContext = unknown, TStrict extends boolean = false> extends FilterChain<TableQueryBuilder<Row, Insert, Update, TContext, TStrict>, Row> {
+    select<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): SelectChain<Row, T, TStrict>;
+    findMany<const TSelect extends AthenaSelectShape>(options: AthenaFindManyOptions<Row, TSelect> & {
+        select: AthenaValidatedSelectShape<TSelect>;
+    }): Promise<AthenaResult<Array<AthenaFindManyResult<Row, TSelect, TContext>>>>;
+    insert(values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row, Row, TStrict>;
+    insert(values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[], Row, TStrict>;
+    upsert(values: Insert, options?: AthenaGatewayCallOptions & {
+        updateBody?: Update;
+        onConflict?: string | string[];
+    }): MutationQuery<Row, Row, TStrict>;
+    upsert(values: Insert[], options?: AthenaGatewayCallOptions & {
+        updateBody?: Update;
+        onConflict?: string | string[];
+    }): MutationQuery<Row[], Row, TStrict>;
+    update(values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row, TStrict>;
+    delete(options?: AthenaGatewayCallOptions & {
+        resourceId?: string;
+    }): MutationQuery<Row | null, Row, TStrict>;
+    single<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row, const TColumns extends AthenaSelectInput = string>(columns?: SelectColumnsFor<Row, TStrict, TColumns>, options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    reset(): TableQueryBuilder<Row, Insert, Update, TContext, TStrict>;
+}
+interface AthenaSdkClient<TStrict extends boolean = false> {
+    from<TModel extends AthenaModelTarget>(model: TModel): TableQueryBuilder<RowOf<TModel>, InsertOf<TModel>, UpdateOf<TModel>, unknown, TStrict>;
+    from<Row = AthenaRowShape, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update, unknown, TStrict>;
+    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[]>>;
+    verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+}
+interface AthenaSdkClientWithAuth<TStrict extends boolean = false> extends AthenaSdkClient<TStrict> {
+    auth: AthenaAuthBindings;
+}
+interface AthenaSdkClientWithStorage<TStrict extends boolean = false> extends AthenaSdkClientWithAuth<TStrict> {
+    storage: AthenaStorageModule;
+}
+interface AthenaCreateClientServiceUrlConfig {
+    url?: string | null;
+}
+interface AthenaCreateClientAuthOptions extends AthenaAuthClientConfig {
+    url?: string | null;
+}
+interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
+    db?: AthenaCreateClientServiceUrlConfig;
+    gateway?: AthenaCreateClientServiceUrlConfig;
+    auth?: AthenaCreateClientAuthOptions;
+    storage?: AthenaCreateClientServiceUrlConfig;
+    dbUrl?: string | null;
+    gatewayUrl?: string | null;
+    authUrl?: string | null;
+    storageUrl?: string | null;
+    experimental?: AthenaClientExperimentalOptions;
+}
+interface AthenaCreateClientOptionsWithStorage extends AthenaCreateClientOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+    };
+}
+interface AthenaCreateClientOptionsWithTypecheckedColumns extends AthenaCreateClientOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        typecheckColumns: true;
+    };
+}
+interface AthenaCreateClientOptionsWithStorageAndTypecheckedColumns extends AthenaCreateClientOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+        typecheckColumns: true;
+    };
+}
+interface AthenaCreateClientConfig extends AthenaCreateClientOptions {
+    url?: string | null;
+    key: string;
+}
+interface AthenaCreateClientConfigWithStorage extends AthenaCreateClientOptionsWithStorage {
+    url?: string | null;
+    key: string;
+}
+interface AthenaCreateClientConfigWithTypecheckedColumns extends AthenaCreateClientOptionsWithTypecheckedColumns {
+    url?: string | null;
+    key: string;
+}
+interface AthenaCreateClientConfigWithStorageAndTypecheckedColumns extends AthenaCreateClientOptionsWithStorageAndTypecheckedColumns {
+    url?: string | null;
+    key: string;
+}
+interface AthenaClientBuilder<StorageEnabled extends boolean = false, TStrict extends boolean = false> {
+    /** Set the public Athena base URL. */
+    url(url: string): AthenaClientBuilder<StorageEnabled, TStrict>;
+    /** Set the API key used for all requests. */
+    key(apiKey: string): 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>;
+    /** Attach static headers to every request. */
+    headers(headers: Record<string, string>): AthenaClientBuilder<StorageEnabled, TStrict>;
+    /** Configure Athena Auth client behavior for `client.auth.*` methods. */
+    auth(config: AthenaCreateClientAuthOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
+    /** Configure experimental client options and narrow the built client when storage or strict column checks are enabled. */
+    experimental(options: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+        typecheckColumns: true;
+    }): AthenaClientBuilder<true, true>;
+    experimental(options: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+    }): AthenaClientBuilder<true, TStrict>;
+    experimental(options: AthenaClientExperimentalOptions & {
+        typecheckColumns: true;
+    }): AthenaClientBuilder<StorageEnabled, true>;
+    experimental(options: AthenaClientExperimentalOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
+    /** Apply createClient options and narrow the built client when storage is enabled. */
+    options(options: AthenaCreateClientOptionsWithStorageAndTypecheckedColumns): AthenaClientBuilder<true, true>;
+    options(options: AthenaCreateClientOptionsWithStorage): AthenaClientBuilder<true, TStrict>;
+    options(options: AthenaCreateClientOptionsWithTypecheckedColumns): AthenaClientBuilder<StorageEnabled, true>;
+    options(options: AthenaCreateClientOptions): AthenaClientBuilder<StorageEnabled, TStrict>;
+    /** Build the immutable Athena SDK client. */
+    build(): StorageEnabled extends true ? AthenaSdkClientWithStorage<TStrict> : AthenaSdkClientWithAuth<TStrict>;
+}
+/** Canonical Athena client factory with builder-based configuration. */
+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>;
+}
+/** 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>;
+
+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 };