@xylex-group/athena 2.6.0 → 2.7.0

package/dist/model-form-AKYrgede.d.ts

@@ -0,0 +1,2772 @@
+import { i as AthenaJsonValue, a as AthenaGatewayCallOptions, g as AthenaJsonObject, j as AthenaRpcCallOptions, W as AthenaGatewayEndpointPath, X as AthenaGatewayMethod, Y as AthenaConditionValue, Z as AthenaConditionArrayValue, R as RegistryDef, D as DatabaseDef, F as SchemaDef, J as AnyModelDef, x as ModelDef, C as ModelRelationMetadata, E as RowOf, o as BackendConfig, p as BackendType, e as AthenaGatewayErrorDetails, A as AthenaConditionCastType, _ as AthenaConditionOperator, b as AthenaGatewayConnectionOptions, c as AthenaGatewayConnectionResult, d as AthenaGatewayErrorCode, P as AthenaGatewayResponse, q as InsertOf, U as UpdateOf } from './types-BsyRW49r.js';
+
+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;
+/**
+ * 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 AthenaRowShape$2 = Record<string, AthenaJsonValue | undefined>;
+type AthenaUpsertOptions<Update> = AthenaGatewayCallOptions & {
+    updateBody?: Update;
+    onConflict?: string | string[];
+};
+interface AthenaDbModule {
+    from<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update>;
+    select<Row = AthenaRowShape$2, SelectedRow = Row>(table: string, columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<Row, SelectedRow>;
+    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: string, values: Insert, options?: AthenaGatewayCallOptions): MutationQuery<Row>;
+    insert<Row = AthenaRowShape$2, Insert = Partial<Row>>(table: string, values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[]>;
+    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert, options?: AthenaUpsertOptions<Update>): MutationQuery<Row>;
+    upsert<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Insert[], options?: AthenaUpsertOptions<Update>): MutationQuery<Row[]>;
+    update<Row = AthenaRowShape$2, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
+    delete<Row = AthenaRowShape$2>(table: string, options?: AthenaGatewayCallOptions & {
+        resourceId?: string;
+    }): MutationQuery<Row | null>;
+    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row>;
+    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;
+}
+interface StorageObjectFolderDeleteRequest extends 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;
+}
+interface StorageBucketCorsRequest extends 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>>;
+
+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;
+    /**
+     * 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;
+    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 AthenaRowShape = Record<string, AthenaJsonValue | undefined>;
+type FilterColumnKey<Row> = Extract<keyof NonNullable<Row>, string>;
+type ResolvedFilterColumnKey<Row> = [FilterColumnKey<Row>] extends [never] ? string : FilterColumnKey<Row>;
+interface MutationQuery<Result> extends PromiseLike<AthenaResult<Result>> {
+    select(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    returning(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<Result>>;
+    single(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<MutationSingleResult<Result>>>;
+    maybeSingle(columns?: string | string[], 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> extends FilterChain<SelectChain<Row, SelectedRow>, Row>, PromiseLike<AthenaResult<SelectedRow[]>> {
+    single<T = SelectedRow>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = SelectedRow>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+}
+/** Chain returned by update() - supports filters before execution, plus select/returning */
+interface UpdateChain<Row> extends FilterChain<UpdateChain<Row>, Row>, MutationQuery<Row[]> {
+}
+interface RpcFilterChain<Self> {
+    eq(column: string, value: AthenaConditionValue): Self;
+    neq(column: string, value: AthenaConditionValue): Self;
+    gt(column: string, value: AthenaConditionValue): Self;
+    gte(column: string, value: AthenaConditionValue): Self;
+    lt(column: string, value: AthenaConditionValue): Self;
+    lte(column: string, value: AthenaConditionValue): Self;
+    like(column: string, value: AthenaConditionValue): Self;
+    ilike(column: string, value: AthenaConditionValue): Self;
+    is(column: string, value: AthenaConditionValue): Self;
+    in(column: string, values: AthenaConditionArrayValue): Self;
+}
+interface RpcOrderOptions {
+    ascending?: boolean;
+}
+interface RpcQueryBuilder<Row> extends RpcFilterChain<RpcQueryBuilder<Row>>, PromiseLike<AthenaResult<Row[]>> {
+    select(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<Row[]>>;
+    single<T = Row>(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaRpcCallOptions): Promise<AthenaResult<T | null>>;
+    order(column: string, options?: RpcOrderOptions): RpcQueryBuilder<Row>;
+    limit(count: number): RpcQueryBuilder<Row>;
+    offset(count: number): RpcQueryBuilder<Row>;
+    range(from: number, to: number): RpcQueryBuilder<Row>;
+}
+interface AthenaFromOptions {
+    schema?: string;
+}
+interface TableQueryBuilder<Row, Insert = Partial<Row>, Update = Partial<Insert>, TContext = unknown> extends FilterChain<TableQueryBuilder<Row, Insert, Update, TContext>, Row> {
+    select<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): SelectChain<Row, T>;
+    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>;
+    insert(values: Insert[], options?: AthenaGatewayCallOptions): MutationQuery<Row[]>;
+    upsert(values: Insert, options?: AthenaGatewayCallOptions & {
+        updateBody?: Update;
+        onConflict?: string | string[];
+    }): MutationQuery<Row>;
+    upsert(values: Insert[], options?: AthenaGatewayCallOptions & {
+        updateBody?: Update;
+        onConflict?: string | string[];
+    }): MutationQuery<Row[]>;
+    update(values: Update, options?: AthenaGatewayCallOptions): UpdateChain<Row>;
+    delete(options?: AthenaGatewayCallOptions & {
+        resourceId?: string;
+    }): MutationQuery<Row | null>;
+    single<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    maybeSingle<T = Row>(columns?: string | string[], options?: AthenaGatewayCallOptions): Promise<AthenaResult<T | null>>;
+    reset(): TableQueryBuilder<Row, Insert, Update, TContext>;
+}
+interface AthenaSdkClient {
+    from<Row = AthenaRowShape, Insert = Partial<Row>, Update = Partial<Insert>>(table: string, options?: AthenaFromOptions): TableQueryBuilder<Row, Insert, Update>;
+    db: AthenaDbModule;
+    rpc<Row = unknown, Args extends AthenaJsonObject = AthenaJsonObject>(fn: string, args?: Args, options?: AthenaRpcCallOptions): RpcQueryBuilder<Row>;
+    query<Row = unknown>(query: string, options?: AthenaGatewayCallOptions): Promise<AthenaResult<Row[]>>;
+    verifyConnection(options?: AthenaGatewayConnectionOptions): Promise<AthenaGatewayConnectionResult>;
+}
+interface AthenaSdkClientWithAuth extends AthenaSdkClient {
+    auth: AthenaAuthBindings;
+}
+interface AthenaSdkClientWithStorage extends AthenaSdkClientWithAuth {
+    storage: AthenaStorageModule;
+}
+interface AthenaCreateClientOptions extends Pick<AthenaGatewayCallOptions, 'client' | 'headers' | 'backend'> {
+    auth?: AthenaAuthClientConfig;
+    experimental?: AthenaClientExperimentalOptions;
+}
+interface AthenaCreateClientOptionsWithStorage extends AthenaCreateClientOptions {
+    experimental: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+    };
+}
+interface AthenaClientBuilder<StorageEnabled extends boolean = false> {
+    /** Set the gateway base URL. */
+    url(url: string): AthenaClientBuilder<StorageEnabled>;
+    /** Set the API key used for all requests. */
+    key(apiKey: string): AthenaClientBuilder<StorageEnabled>;
+    /** Set the default backend routing strategy. */
+    backend(backend: BackendConfig | BackendType): AthenaClientBuilder<StorageEnabled>;
+    /** Set the default Athena client routing key. */
+    client(clientName: string): AthenaClientBuilder<StorageEnabled>;
+    /** Attach static headers to every request. */
+    headers(headers: Record<string, string>): AthenaClientBuilder<StorageEnabled>;
+    /** Configure Athena Auth client behavior for `client.auth.*` methods. */
+    auth(config: AthenaAuthClientConfig): AthenaClientBuilder<StorageEnabled>;
+    /** Configure experimental client options and narrow the built client when storage is enabled. */
+    experimental(options: AthenaClientExperimentalOptions & {
+        athenaStorageBackend: true;
+    }): AthenaClientBuilder<true>;
+    experimental(options: AthenaClientExperimentalOptions): AthenaClientBuilder<StorageEnabled>;
+    /** Apply createClient options and narrow the built client when storage is enabled. */
+    options(options: AthenaCreateClientOptionsWithStorage): AthenaClientBuilder<true>;
+    options(options: AthenaCreateClientOptions): AthenaClientBuilder<StorageEnabled>;
+    /** Build the immutable Athena SDK client. */
+    build(): StorageEnabled extends true ? AthenaSdkClientWithStorage : AthenaSdkClientWithAuth;
+}
+/** 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>;
+    /** Build a client from process environment variables. */
+    static fromEnvironment(): AthenaSdkClientWithAuth;
+}
+/** Create client (convenience wrapper; use AthenaClient.builder() for full control) */
+declare function createClient(url: string, apiKey: string, options: AthenaCreateClientOptionsWithStorage): AthenaSdkClientWithStorage;
+declare function createClient(url: string, apiKey: string, options?: AthenaCreateClientOptions): AthenaSdkClientWithAuth;
+
+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>;
+};
+/**
+ * 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 AthenaUnlinkAccountRequest as a$, type AthenaCreateClientOptions as a0, type AthenaCreateClientOptionsWithStorage as a1, type AthenaDbModule as a2, type AthenaDeleteUserCallbackRequest as a3, type AthenaDeleteUserRequest as a4, type AthenaDeleteUserResponse as a5, type AthenaEmailSignInRequest as a6, type AthenaEmailSignUpRequest as a7, type AthenaEnvelope as a8, AthenaError as a9, type AthenaSocialSignInRequest as aA, type AthenaStorageBinaryCallOptions as aB, type AthenaStorageCallOptions as aC, type AthenaStorageClientConfig as aD, type AthenaStorageEnv as aE, AthenaStorageError as aF, AthenaStorageErrorCode as aG, type AthenaStorageErrorDetails as aH, type AthenaStorageErrorHandler as aI, type AthenaStorageErrorInput as aJ, type AthenaStorageFileConfig as aK, type AthenaStorageFileDeleteInput as aL, type AthenaStorageFileDownloadInput as aM, type AthenaStorageFileListInput as aN, type AthenaStorageFileModule as aO, type AthenaStorageFileUploadInput as aP, type AthenaStorageFileUploadResult as aQ, type AthenaStorageModule as aR, type AthenaStoragePathContext as aS, type AthenaStoragePrefixPath as aT, type AthenaStorageTemplateValue as aU, type AthenaStorageTemplateVars as aV, type AthenaStorageUploadConstraints as aW, type AthenaStorageUploadProgress as aX, type AthenaStorageUploadProgressHandler as aY, type AthenaStorageUploadSource as aZ, type AthenaStorageUploadedFile as a_, AthenaErrorCategory as aa, AthenaErrorCode as ab, type AthenaErrorInput as ac, AthenaErrorKind as ad, type AthenaFindManyOptions as ae, type AthenaFindManyResult as af, type AthenaForgetPasswordRequest as ag, type AthenaFromOptions as ah, AthenaGatewayError as ai, type AthenaLinkSocialRequest as aj, type AthenaOAuthAccountTokenRequest as ak, type AthenaOAuthTokenBundle as al, type AthenaOperationContext as am, type AthenaOrderBy as an, type AthenaQueryTraceCallsite as ao, type AthenaQueryTraceEvent as ap, type AthenaQueryTraceOptions as aq, type AthenaRelationSelectNode as ar, type AthenaResetPasswordRequest as as, type AthenaResult as at, type AthenaResultError as au, type AthenaSdkClient as av, type AthenaSdkClientWithAuth as aw, type AthenaSdkClientWithStorage as ax, type AthenaSelectShape as ay, type AthenaSendVerificationEmailRequest as az, type AthenaAdminListUsersSearchOperator as b, type AthenaUpdateUserRequest as b0, type AthenaUsernameSignInRequest as b1, type AthenaVerifyEmailRequest as b2, type AthenaWhere as b3, type AthenaWhereBooleanOperand as b4, type AthenaWhereOperatorInput as b5, type CreateStorageCatalogRequest as b6, type CreateStorageUploadUrlRequest as b7, type CreateStorageUploadUrlsRequest as b8, type DeleteStorageFolderRequest as b9, type ToModelFormDefaultsOptions as bA, type ToModelPayloadOptions as bB, type UnwrapOneOptions as bC, type UnwrapOptions as bD, type UpdateStorageCatalogRequest as bE, type UpdateStorageFileRequest as bF, assertInt as bG, coerceInt as bH, createAthenaStorageError as bI, createClient as bJ, createModelFormAdapter as bK, isAthenaGatewayError as bL, isOk as bM, normalizeAthenaError as bN, parseBooleanFlag as bO, requireAffected as bP, requireSuccess as bQ, storageSdkManifest as bR, toModelFormDefaults as bS, toModelPayload as bT, unwrap as bU, unwrapOne as bV, unwrapRows as bW, withRetry as bX, type AthenaAuthFetchCompatibleInput as bY, type GetStorageFileUrlQuery as ba, type IntCoercionOptions as bb, type ListStorageFilesRequest as bc, type ManagedFileRecord as bd, type ModelFormAdapter as be, type ModelFormDefaults as bf, type ModelFormNullishMode as bg, type ModelFormValues as bh, type MoveStorageFolderRequest as bi, type NormalizedAthenaError as bj, type PresignedFileUrlResponse as bk, type RequireAffectedOptions as bl, type RetryBackoffStrategy as bm, type RetryConfig as bn, type RpcOrderOptions as bo, type RpcQueryBuilder as bp, type S3CatalogItem as bq, type S3CredentialListItem as br, type SetStorageFileVisibilityRequest as bs, type StorageBatchUploadUrlResponse as bt, type StorageFileAccessPurpose as bu, type StorageFileMutationResponse as bv, type StorageFolderMutationResponse as bw, type StorageListFilesResponse as bx, type StorageUploadUrlResponse as by, type TableQueryBuilder as bz, type AthenaAuthAdminUserSessionRevokeBinding as c, 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 };