@parsrun/types 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2119 @@
+import * as arktype from 'arktype';
+import { Type, type } from 'arktype';
+export { Type, type } from 'arktype';
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+import * as arktype_internal_variants_number_ts from 'arktype/internal/variants/number.ts';
+import * as arktype_internal_variants_string_ts from 'arktype/internal/variants/string.ts';
+
+/**
+ * @parsrun/types - Common Schemas
+ * Shared validation schemas used across all Pars packages
+ */
+/** UUID v4 string validation */
+declare const uuid: arktype_internal_variants_string_ts.StringType<string, {}>;
+/** ISO 8601 timestamp string */
+declare const timestamp: arktype_internal_variants_string_ts.StringType<string, {}>;
+/** Email address validation */
+declare const email: arktype_internal_variants_string_ts.StringType<string, {}>;
+/** URL validation */
+declare const url: arktype_internal_variants_string_ts.StringType<string, {}>;
+/** Non-empty string */
+declare const nonEmptyString: arktype_internal_variants_string_ts.StringType<string, {}>;
+/** Positive integer */
+declare const positiveInt: arktype_internal_variants_number_ts.NumberType<number, {}>;
+/** Non-negative integer */
+declare const nonNegativeInt: arktype_internal_variants_number_ts.NumberType<number, {}>;
+/** Common entity status */
+declare const status: arktype_internal_variants_string_ts.StringType<"active" | "inactive" | "suspended" | "deleted", {}>;
+/** Session status */
+declare const sessionStatus: arktype_internal_variants_string_ts.StringType<"active" | "expired" | "revoked", {}>;
+/** Pagination request parameters */
+declare const pagination: arktype_internal_variants_object_ts.ObjectType<{
+    page: number;
+    limit: number;
+    orderBy?: string;
+    orderDirection?: "asc" | "desc";
+}, {}>;
+/** Pagination metadata in responses */
+declare const paginationMeta: arktype_internal_variants_object_ts.ObjectType<{
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+}, {}>;
+/** Cursor-based pagination */
+declare const cursorPagination: arktype_internal_variants_object_ts.ObjectType<{
+    limit: number;
+    cursor?: string;
+    direction?: "forward" | "backward";
+}, {}>;
+/** Cursor pagination metadata */
+declare const cursorPaginationMeta: arktype_internal_variants_object_ts.ObjectType<{
+    hasMore: boolean;
+    limit: number;
+    cursor?: string;
+    nextCursor?: string;
+    prevCursor?: string;
+}, {}>;
+/** Success response wrapper */
+declare const successResponse: <T>(dataSchema: T) => arktype_internal_variants_object_ts.ObjectType<{
+    success: "true";
+    data: never;
+    message?: string;
+}, {}>;
+/** Error response */
+declare const errorResponse: arktype_internal_variants_object_ts.ObjectType<{
+    success: "false";
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+    message?: string;
+}, {}>;
+/** Paginated response wrapper */
+declare const paginatedResponse: <T>(dataSchema: T) => arktype_internal_variants_object_ts.ObjectType<{
+    success: boolean;
+    data: never;
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    };
+    message?: string;
+}, {}>;
+/** Cursor paginated response wrapper */
+declare const cursorPaginatedResponse: <T>(dataSchema: T) => arktype_internal_variants_object_ts.ObjectType<{
+    success: boolean;
+    data: never;
+    pagination: {
+        hasMore: boolean;
+        limit: number;
+        cursor?: string;
+        nextCursor?: string;
+        prevCursor?: string;
+    };
+    message?: string;
+}, {}>;
+/** Pars framework error */
+declare const parsError: arktype_internal_variants_object_ts.ObjectType<{
+    message: string;
+    statusCode: number;
+    code?: string;
+    details?: unknown;
+}, {}>;
+/** Validation error details */
+declare const validationErrorDetail: arktype_internal_variants_object_ts.ObjectType<{
+    path: string;
+    message: string;
+    expected?: string;
+    received?: unknown;
+}, {}>;
+type UUID = typeof uuid.infer;
+type Timestamp = typeof timestamp.infer;
+type Email = typeof email.infer;
+type Url = typeof url.infer;
+type NonEmptyString = typeof nonEmptyString.infer;
+type PositiveInt = typeof positiveInt.infer;
+type NonNegativeInt = typeof nonNegativeInt.infer;
+type Status = typeof status.infer;
+type SessionStatus = typeof sessionStatus.infer;
+type Pagination = typeof pagination.infer;
+type PaginationMeta = typeof paginationMeta.infer;
+type CursorPagination = typeof cursorPagination.infer;
+type CursorPaginationMeta = typeof cursorPaginationMeta.infer;
+type ErrorResponse = typeof errorResponse.infer;
+type ParsError = typeof parsError.infer;
+type ValidationErrorDetail = typeof validationErrorDetail.infer;
+interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    message?: string;
+}
+interface ApiErrorResponse {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+    message?: string;
+}
+interface ApiPaginatedResponse<T = unknown> {
+    success: boolean;
+    data: T[];
+    pagination: PaginationMeta;
+    message?: string;
+}
+interface ApiCursorPaginatedResponse<T = unknown> {
+    success: boolean;
+    data: T[];
+    pagination: CursorPaginationMeta;
+    message?: string;
+}
+
+/**
+ * @parsrun/types - Auth Schemas
+ * Authentication and authorization validation schemas
+ */
+/** User entity */
+declare const user: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    twoFactorEnabled: boolean;
+    status: "active" | "inactive" | "suspended" | "deleted";
+    insertedAt: string;
+    updatedAt: string;
+    displayName?: string;
+    twoFactorSecret?: string;
+    deletedAt?: string;
+}, {}>;
+/** Auth method (email, phone, OAuth providers) */
+declare const authMethod: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    userId: string;
+    provider: "email" | "phone" | "google" | "github" | "microsoft" | "apple";
+    providerId: string;
+    verified: boolean;
+    insertedAt: string;
+    updatedAt: string;
+    metadata?: object;
+    deletedAt?: string;
+}, {}>;
+/** Session entity */
+declare const session: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    userId: string;
+    csrfTokenHash: string;
+    expiresAt: string;
+    status: "active" | "expired" | "revoked";
+    lastActivityAt: string;
+    insertedAt: string;
+    updatedAt: string;
+    authMethodId?: string;
+    currentTenantId?: string;
+    refreshTokenHash?: string;
+    refreshExpiresAt?: string;
+    deviceType?: "mobile" | "desktop" | "tablet" | "api";
+    deviceName?: string;
+    userAgent?: string;
+    ipAddress?: string;
+    locationData?: object;
+    deviceFingerprint?: string;
+    revokedAt?: string;
+    revokedReason?: "user_logout" | "admin_revoke" | "security_breach" | "suspicious_activity";
+    deletedAt?: string;
+}, {}>;
+/** Tenant membership */
+declare const tenantMembership: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    userId: string;
+    tenantId: string;
+    roleId: string;
+    status: "active" | "inactive" | "suspended" | "invited";
+    permissions: object;
+    accessLevel: "full" | "limited" | "read_only";
+    resourceRestrictions: object;
+    insertedAt: string;
+    updatedAt: string;
+    ipRestrictions?: object;
+    timeRestrictions?: object;
+    expiresAt?: string;
+    invitedBy?: string;
+    invitedAt?: string;
+    joinedAt?: string;
+    lastLoginAt?: string;
+    deletedAt?: string;
+}, {}>;
+/** Request OTP (email/phone) */
+declare const requestOTPRequest: arktype_internal_variants_object_ts.ObjectType<{
+    email?: string;
+    phone?: string;
+    tenantId?: string;
+}, {}>;
+/** OTP request response */
+declare const requestOTPResponse: arktype_internal_variants_object_ts.ObjectType<{
+    success: boolean;
+    message: string;
+    expiresAt?: string;
+    requiresTenantSelection?: boolean;
+    isNewUser?: boolean;
+    defaultTenantId?: string;
+    defaultTenantName?: string;
+    selectedTenantId?: string;
+    selectedTenantName?: string;
+    tenants?: {
+        id: string;
+        name: string;
+        role: string;
+    }[];
+}, {}>;
+/** Verify OTP */
+declare const verifyOTPRequest: arktype_internal_variants_object_ts.ObjectType<{
+    code: string;
+    email?: string;
+    phone?: string;
+    tenantId?: string;
+}, {}>;
+/** Resend OTP */
+declare const resendOTPRequest: arktype_internal_variants_object_ts.ObjectType<{
+    email?: string;
+    phone?: string;
+}, {}>;
+/** Login response data */
+declare const loginResponseData: arktype_internal_variants_object_ts.ObjectType<{
+    user: {
+        id: string;
+        twoFactorEnabled: boolean;
+        status: "active" | "inactive" | "suspended" | "deleted";
+        insertedAt: string;
+        updatedAt: string;
+        displayName?: string;
+        twoFactorSecret?: string;
+        deletedAt?: string;
+    };
+    session: {
+        accessToken: string;
+        expiresAt: string;
+        csrfToken: string;
+    };
+    authMethod: {
+        id: string;
+        provider: "email" | "phone" | "google" | "github" | "microsoft" | "apple";
+        providerId: string;
+        verified: boolean;
+        metadata?: object;
+    };
+    isNewUser: boolean;
+    refreshToken?: string;
+    tenantMemberships?: {
+        id: string;
+        userId: string;
+        tenantId: string;
+        roleId: string;
+        status: "active" | "inactive" | "suspended" | "invited";
+        permissions: object;
+        accessLevel: "full" | "limited" | "read_only";
+        resourceRestrictions: object;
+        insertedAt: string;
+        updatedAt: string;
+        ipRestrictions?: object;
+        timeRestrictions?: object;
+        expiresAt?: string;
+        invitedBy?: string;
+        invitedAt?: string;
+        joinedAt?: string;
+        lastLoginAt?: string;
+        deletedAt?: string;
+    }[];
+}, {}>;
+/** Login response */
+declare const loginResponse: arktype_internal_variants_object_ts.ObjectType<{
+    success: boolean;
+    data: {
+        user: {
+            id: string;
+            twoFactorEnabled: boolean;
+            status: "active" | "inactive" | "suspended" | "deleted";
+            insertedAt: string;
+            updatedAt: string;
+            displayName?: string;
+            twoFactorSecret?: string;
+            deletedAt?: string;
+        };
+        session: {
+            accessToken: string;
+            expiresAt: string;
+            csrfToken: string;
+        };
+        authMethod: {
+            id: string;
+            provider: "email" | "phone" | "google" | "github" | "microsoft" | "apple";
+            providerId: string;
+            verified: boolean;
+            metadata?: object;
+        };
+        isNewUser: boolean;
+        refreshToken?: string;
+        tenantMemberships?: {
+            id: string;
+            userId: string;
+            tenantId: string;
+            roleId: string;
+            status: "active" | "inactive" | "suspended" | "invited";
+            permissions: object;
+            accessLevel: "full" | "limited" | "read_only";
+            resourceRestrictions: object;
+            insertedAt: string;
+            updatedAt: string;
+            ipRestrictions?: object;
+            timeRestrictions?: object;
+            expiresAt?: string;
+            invitedBy?: string;
+            invitedAt?: string;
+            joinedAt?: string;
+            lastLoginAt?: string;
+            deletedAt?: string;
+        }[];
+    };
+    message?: string;
+}, {}>;
+/** Current user response data */
+declare const currentUserResponseData: arktype_internal_variants_object_ts.ObjectType<{
+    user: {
+        id: string;
+        twoFactorEnabled: boolean;
+        status: "active" | "inactive" | "suspended" | "deleted";
+        insertedAt: string;
+        updatedAt: string;
+        displayName?: string;
+        twoFactorSecret?: string;
+        deletedAt?: string;
+    };
+    tenantMemberships: {
+        id: string;
+        userId: string;
+        tenantId: string;
+        roleId: string;
+        status: "active" | "inactive" | "suspended" | "invited";
+        permissions: object;
+        accessLevel: "full" | "limited" | "read_only";
+        resourceRestrictions: object;
+        insertedAt: string;
+        updatedAt: string;
+        ipRestrictions?: object;
+        timeRestrictions?: object;
+        expiresAt?: string;
+        invitedBy?: string;
+        invitedAt?: string;
+        joinedAt?: string;
+        lastLoginAt?: string;
+        deletedAt?: string;
+    }[];
+    roles: {
+        id: string;
+        name: string;
+        description?: string;
+    }[];
+    permissions: string[];
+    currentTenant: string;
+    authMethod?: {
+        id: string;
+        provider: "email" | "phone" | "google" | "github" | "microsoft" | "apple";
+        providerId: string;
+        verified: boolean;
+        metadata?: object;
+    };
+}, {}>;
+/** Current user response */
+declare const currentUserResponse: arktype_internal_variants_object_ts.ObjectType<{
+    success: boolean;
+    data: {
+        user: {
+            id: string;
+            twoFactorEnabled: boolean;
+            status: "active" | "inactive" | "suspended" | "deleted";
+            insertedAt: string;
+            updatedAt: string;
+            displayName?: string;
+            twoFactorSecret?: string;
+            deletedAt?: string;
+        };
+        tenantMemberships: {
+            id: string;
+            userId: string;
+            tenantId: string;
+            roleId: string;
+            status: "active" | "inactive" | "suspended" | "invited";
+            permissions: object;
+            accessLevel: "full" | "limited" | "read_only";
+            resourceRestrictions: object;
+            insertedAt: string;
+            updatedAt: string;
+            ipRestrictions?: object;
+            timeRestrictions?: object;
+            expiresAt?: string;
+            invitedBy?: string;
+            invitedAt?: string;
+            joinedAt?: string;
+            lastLoginAt?: string;
+            deletedAt?: string;
+        }[];
+        roles: {
+            id: string;
+            name: string;
+            description?: string;
+        }[];
+        permissions: string[];
+        currentTenant: string;
+        authMethod?: {
+            id: string;
+            provider: "email" | "phone" | "google" | "github" | "microsoft" | "apple";
+            providerId: string;
+            verified: boolean;
+            metadata?: object;
+        };
+    };
+    message?: string;
+}, {}>;
+/** Refresh token request */
+declare const refreshTokenRequest: arktype_internal_variants_object_ts.ObjectType<{
+    refreshToken: string;
+}, {}>;
+/** Token info (for client storage) */
+declare const tokenInfo: arktype_internal_variants_object_ts.ObjectType<{
+    accessToken: string;
+    expiresAt: Date;
+    csrfToken: string;
+    refreshToken?: string;
+    tenantId?: string;
+}, {}>;
+/** JWT payload */
+declare const jwtPayload: arktype_internal_variants_object_ts.ObjectType<{
+    sub: string;
+    tenantId: string;
+    iat: number;
+    exp: number;
+    sessionId?: string;
+    roles?: string[];
+    permissions?: string[];
+    aud?: string;
+    iss?: string;
+}, {}>;
+/** Permission entity */
+declare const permission: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    name: string;
+    resource: string;
+    action: "delete" | "read" | "create" | "update" | "list" | "manage";
+    scope: "global" | "own" | "tenant";
+    isSystem: boolean;
+    insertedAt: string;
+    updatedAt: string;
+    description?: string;
+}, {}>;
+/** Role entity */
+declare const role: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    tenantId: string;
+    name: string;
+    isSystem: boolean;
+    isActive: boolean;
+    insertedAt: string;
+    updatedAt: string;
+    description?: string;
+    color?: string;
+    deletedAt?: string;
+}, {}>;
+/** Permission check request */
+declare const permissionCheck: arktype_internal_variants_object_ts.ObjectType<{
+    resource: string;
+    action: string;
+    scope?: "global" | "own" | "tenant";
+    resourceId?: string;
+}, {}>;
+/** Logout request */
+declare const logoutRequest: arktype_internal_variants_object_ts.ObjectType<{
+    allDevices: boolean;
+    refreshToken?: string;
+}, {}>;
+/** Revoke session request */
+declare const revokeSessionRequest: arktype_internal_variants_object_ts.ObjectType<{
+    reason?: "user_logout" | "admin_revoke" | "security_breach" | "suspicious_activity";
+}, {}>;
+/** Revoke all sessions request */
+declare const revokeAllSessionsRequest: arktype_internal_variants_object_ts.ObjectType<{
+    reason?: "user_logout" | "admin_revoke" | "security_breach" | "suspicious_activity";
+    excludeCurrent?: boolean;
+}, {}>;
+/** Revoke all sessions response */
+declare const revokeAllSessionsResponse: arktype_internal_variants_object_ts.ObjectType<{
+    success: boolean;
+    message: string;
+    revokedCount: number;
+}, {}>;
+/** Send verification email request */
+declare const sendVerificationEmailRequest: arktype_internal_variants_object_ts.ObjectType<{
+    email: string;
+}, {}>;
+/** Verify email request */
+declare const verifyEmailRequest: arktype_internal_variants_object_ts.ObjectType<{
+    token: string;
+}, {}>;
+/** Check verification status */
+declare const checkVerificationStatusRequest: arktype_internal_variants_object_ts.ObjectType<{
+    email: string;
+}, {}>;
+declare const checkVerificationStatusResponse: arktype_internal_variants_object_ts.ObjectType<{
+    success: boolean;
+    verified: boolean;
+    message: string;
+    sentAt?: string;
+    expiresAt?: string;
+}, {}>;
+/** CSRF token validation */
+declare const csrfTokenRequest: arktype_internal_variants_object_ts.ObjectType<{
+    csrfToken: string;
+}, {}>;
+/** Session config */
+declare const sessionConfig: arktype_internal_variants_object_ts.ObjectType<{
+    accessTokenExpiry?: number;
+    refreshTokenExpiry?: number;
+    slidingWindow?: boolean;
+    maxSessions?: number;
+    invalidateOnPasswordChange?: boolean;
+}, {}>;
+/** JWT config */
+declare const jwtConfig: arktype_internal_variants_object_ts.ObjectType<{
+    algorithm?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512";
+    issuer?: string;
+    audience?: string | string[];
+}, {}>;
+/** Cookie config */
+declare const cookieConfig: arktype_internal_variants_object_ts.ObjectType<{
+    prefix?: string;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    sameSite?: "strict" | "lax" | "none";
+    httpOnly?: boolean;
+}, {}>;
+/** CSRF config */
+declare const csrfConfig: arktype_internal_variants_object_ts.ObjectType<{
+    enabled?: boolean;
+    headerName?: string;
+    cookieName?: string;
+}, {}>;
+/** Rate limit config */
+declare const rateLimitConfig: arktype_internal_variants_object_ts.ObjectType<{
+    enabled?: boolean;
+    loginAttempts?: number;
+    windowSize?: number;
+}, {}>;
+/** Lockout config */
+declare const lockoutConfig: arktype_internal_variants_object_ts.ObjectType<{
+    enabled?: boolean;
+    maxAttempts?: number;
+    duration?: number;
+}, {}>;
+/** Security config */
+declare const securityConfig: arktype_internal_variants_object_ts.ObjectType<{
+    rateLimit?: {
+        enabled?: boolean;
+        loginAttempts?: number;
+        windowSize?: number;
+    };
+    lockout?: {
+        enabled?: boolean;
+        maxAttempts?: number;
+        duration?: number;
+    };
+    csrf?: {
+        enabled?: boolean;
+        headerName?: string;
+        cookieName?: string;
+    };
+}, {}>;
+/** Tenant config */
+declare const tenantConfig: arktype_internal_variants_object_ts.ObjectType<{
+    enabled?: boolean;
+    strategy?: "path" | "subdomain" | "header" | "query" | "custom";
+    headerName?: string;
+    resolver?: Function;
+}, {}>;
+/** OAuth provider config */
+declare const oauthProviderConfig: arktype_internal_variants_object_ts.ObjectType<{
+    clientId: string;
+    clientSecret: string;
+    enabled?: boolean;
+    scopes?: string[];
+    callbackUrl?: string;
+}, {}>;
+/** OTP email config */
+declare const otpEmailConfig: arktype_internal_variants_object_ts.ObjectType<{
+    send: Function;
+    enabled?: boolean;
+    expiresIn?: number;
+    length?: number;
+    maxAttempts?: number;
+    rateLimit?: number;
+    rateLimitWindow?: number;
+}, {}>;
+/** OTP SMS config */
+declare const otpSmsConfig: arktype_internal_variants_object_ts.ObjectType<{
+    send: Function;
+    enabled?: boolean;
+    expiresIn?: number;
+    length?: number;
+    maxAttempts?: number;
+    rateLimit?: number;
+    rateLimitWindow?: number;
+}, {}>;
+/** OTP config */
+declare const otpConfig: arktype_internal_variants_object_ts.ObjectType<{
+    enabled?: boolean;
+    email?: {
+        send: Function;
+        enabled?: boolean;
+        expiresIn?: number;
+        length?: number;
+        maxAttempts?: number;
+        rateLimit?: number;
+        rateLimitWindow?: number;
+    };
+    sms?: {
+        send: Function;
+        enabled?: boolean;
+        expiresIn?: number;
+        length?: number;
+        maxAttempts?: number;
+        rateLimit?: number;
+        rateLimitWindow?: number;
+    };
+}, {}>;
+/** Magic link config */
+declare const magicLinkConfig: arktype_internal_variants_object_ts.ObjectType<{
+    send: Function;
+    enabled?: boolean;
+    expiresIn?: number;
+}, {}>;
+/** TOTP config */
+declare const totpConfig: arktype_internal_variants_object_ts.ObjectType<{
+    enabled?: boolean;
+    issuer?: string;
+    backupCodesCount?: number;
+}, {}>;
+/** WebAuthn config */
+declare const webauthnConfig: arktype_internal_variants_object_ts.ObjectType<{
+    rpName: string;
+    rpId: string;
+    enabled?: boolean;
+    origins?: string[];
+}, {}>;
+/** Password config */
+declare const passwordConfig: arktype_internal_variants_object_ts.ObjectType<{
+    enabled?: boolean;
+    minLength?: number;
+    requireUppercase?: boolean;
+    requireLowercase?: boolean;
+    requireNumbers?: boolean;
+    requireSymbols?: boolean;
+    checkCommonPasswords?: boolean;
+}, {}>;
+/** OAuth providers config */
+declare const oauthProvidersConfig: arktype_internal_variants_object_ts.ObjectType<{
+    google?: {
+        clientId: string;
+        clientSecret: string;
+        enabled?: boolean;
+        scopes?: string[];
+        callbackUrl?: string;
+    };
+    github?: {
+        clientId: string;
+        clientSecret: string;
+        enabled?: boolean;
+        scopes?: string[];
+        callbackUrl?: string;
+    };
+    microsoft?: {
+        clientId: string;
+        clientSecret: string;
+        enabled?: boolean;
+        scopes?: string[];
+        callbackUrl?: string;
+    };
+    apple?: {
+        clientId: string;
+        clientSecret: string;
+        enabled?: boolean;
+        scopes?: string[];
+        callbackUrl?: string;
+    };
+    custom?: Record<string, unknown>;
+}, {}>;
+/** Providers config */
+declare const providersConfig: arktype_internal_variants_object_ts.ObjectType<{
+    otp?: {
+        enabled?: boolean;
+        email?: {
+            send: Function;
+            enabled?: boolean;
+            expiresIn?: number;
+            length?: number;
+            maxAttempts?: number;
+            rateLimit?: number;
+            rateLimitWindow?: number;
+        };
+        sms?: {
+            send: Function;
+            enabled?: boolean;
+            expiresIn?: number;
+            length?: number;
+            maxAttempts?: number;
+            rateLimit?: number;
+            rateLimitWindow?: number;
+        };
+    };
+    magicLink?: {
+        send: Function;
+        enabled?: boolean;
+        expiresIn?: number;
+    };
+    oauth?: {
+        google?: {
+            clientId: string;
+            clientSecret: string;
+            enabled?: boolean;
+            scopes?: string[];
+            callbackUrl?: string;
+        };
+        github?: {
+            clientId: string;
+            clientSecret: string;
+            enabled?: boolean;
+            scopes?: string[];
+            callbackUrl?: string;
+        };
+        microsoft?: {
+            clientId: string;
+            clientSecret: string;
+            enabled?: boolean;
+            scopes?: string[];
+            callbackUrl?: string;
+        };
+        apple?: {
+            clientId: string;
+            clientSecret: string;
+            enabled?: boolean;
+            scopes?: string[];
+            callbackUrl?: string;
+        };
+        custom?: Record<string, unknown>;
+    };
+    totp?: {
+        enabled?: boolean;
+        issuer?: string;
+        backupCodesCount?: number;
+    };
+    webauthn?: {
+        rpName: string;
+        rpId: string;
+        enabled?: boolean;
+        origins?: string[];
+    };
+    password?: {
+        enabled?: boolean;
+        minLength?: number;
+        requireUppercase?: boolean;
+        requireLowercase?: boolean;
+        requireNumbers?: boolean;
+        requireSymbols?: boolean;
+        checkCommonPasswords?: boolean;
+    };
+}, {}>;
+/** Storage config */
+declare const storageConfig: arktype_internal_variants_object_ts.ObjectType<{
+    type?: "custom" | "redis" | "upstash" | "memory" | "cloudflare-kv" | "deno-kv";
+    redis?: object;
+    upstash?: object;
+    cloudflareKv?: object;
+    denoKv?: object;
+    custom?: object;
+}, {}>;
+/** Main Pars auth config */
+declare const parsAuthConfig: arktype_internal_variants_object_ts.ObjectType<{
+    secret: string;
+    adapter: object;
+    baseUrl?: string;
+    storage?: {
+        type?: "custom" | "redis" | "upstash" | "memory" | "cloudflare-kv" | "deno-kv";
+        redis?: object;
+        upstash?: object;
+        cloudflareKv?: object;
+        denoKv?: object;
+        custom?: object;
+    };
+    providers?: {
+        otp?: {
+            enabled?: boolean;
+            email?: {
+                send: Function;
+                enabled?: boolean;
+                expiresIn?: number;
+                length?: number;
+                maxAttempts?: number;
+                rateLimit?: number;
+                rateLimitWindow?: number;
+            };
+            sms?: {
+                send: Function;
+                enabled?: boolean;
+                expiresIn?: number;
+                length?: number;
+                maxAttempts?: number;
+                rateLimit?: number;
+                rateLimitWindow?: number;
+            };
+        };
+        magicLink?: {
+            send: Function;
+            enabled?: boolean;
+            expiresIn?: number;
+        };
+        oauth?: {
+            google?: {
+                clientId: string;
+                clientSecret: string;
+                enabled?: boolean;
+                scopes?: string[];
+                callbackUrl?: string;
+            };
+            github?: {
+                clientId: string;
+                clientSecret: string;
+                enabled?: boolean;
+                scopes?: string[];
+                callbackUrl?: string;
+            };
+            microsoft?: {
+                clientId: string;
+                clientSecret: string;
+                enabled?: boolean;
+                scopes?: string[];
+                callbackUrl?: string;
+            };
+            apple?: {
+                clientId: string;
+                clientSecret: string;
+                enabled?: boolean;
+                scopes?: string[];
+                callbackUrl?: string;
+            };
+            custom?: Record<string, unknown>;
+        };
+        totp?: {
+            enabled?: boolean;
+            issuer?: string;
+            backupCodesCount?: number;
+        };
+        webauthn?: {
+            rpName: string;
+            rpId: string;
+            enabled?: boolean;
+            origins?: string[];
+        };
+        password?: {
+            enabled?: boolean;
+            minLength?: number;
+            requireUppercase?: boolean;
+            requireLowercase?: boolean;
+            requireNumbers?: boolean;
+            requireSymbols?: boolean;
+            checkCommonPasswords?: boolean;
+        };
+    };
+    session?: {
+        accessTokenExpiry?: number;
+        refreshTokenExpiry?: number;
+        slidingWindow?: boolean;
+        maxSessions?: number;
+        invalidateOnPasswordChange?: boolean;
+    };
+    jwt?: {
+        algorithm?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512";
+        issuer?: string;
+        audience?: string | string[];
+    };
+    cookies?: {
+        prefix?: string;
+        domain?: string;
+        path?: string;
+        secure?: boolean;
+        sameSite?: "strict" | "lax" | "none";
+        httpOnly?: boolean;
+    };
+    security?: {
+        rateLimit?: {
+            enabled?: boolean;
+            loginAttempts?: number;
+            windowSize?: number;
+        };
+        lockout?: {
+            enabled?: boolean;
+            maxAttempts?: number;
+            duration?: number;
+        };
+        csrf?: {
+            enabled?: boolean;
+            headerName?: string;
+            cookieName?: string;
+        };
+    };
+    tenant?: {
+        enabled?: boolean;
+        strategy?: "path" | "subdomain" | "header" | "query" | "custom";
+        headerName?: string;
+        resolver?: Function;
+    };
+    callbacks?: object;
+}, {}>;
+type User = typeof user.infer;
+type AuthMethod = typeof authMethod.infer;
+type Session = typeof session.infer;
+type TenantMembership = typeof tenantMembership.infer;
+type RequestOTPRequest = typeof requestOTPRequest.infer;
+type RequestOTPResponse = typeof requestOTPResponse.infer;
+type VerifyOTPRequest = typeof verifyOTPRequest.infer;
+type ResendOTPRequest = typeof resendOTPRequest.infer;
+type LoginResponseData = typeof loginResponseData.infer;
+type LoginResponse = typeof loginResponse.infer;
+type CurrentUserResponseData = typeof currentUserResponseData.infer;
+type CurrentUserResponse = typeof currentUserResponse.infer;
+type RefreshTokenRequest = typeof refreshTokenRequest.infer;
+type TokenInfo = typeof tokenInfo.infer;
+type JwtPayload = typeof jwtPayload.infer;
+type Permission = typeof permission.infer;
+type Role = typeof role.infer;
+type PermissionCheck = typeof permissionCheck.infer;
+type LogoutRequest = typeof logoutRequest.infer;
+type RevokeSessionRequest = typeof revokeSessionRequest.infer;
+type RevokeAllSessionsRequest = typeof revokeAllSessionsRequest.infer;
+type RevokeAllSessionsResponse = typeof revokeAllSessionsResponse.infer;
+type SendVerificationEmailRequest = typeof sendVerificationEmailRequest.infer;
+type VerifyEmailRequest = typeof verifyEmailRequest.infer;
+type CheckVerificationStatusRequest = typeof checkVerificationStatusRequest.infer;
+type CheckVerificationStatusResponse = typeof checkVerificationStatusResponse.infer;
+type CSRFTokenRequest = typeof csrfTokenRequest.infer;
+type SessionConfig = typeof sessionConfig.infer;
+type JwtConfig = typeof jwtConfig.infer;
+type CookieConfig = typeof cookieConfig.infer;
+type CsrfConfig = typeof csrfConfig.infer;
+type RateLimitConfig = typeof rateLimitConfig.infer;
+type LockoutConfig = typeof lockoutConfig.infer;
+type SecurityConfig = typeof securityConfig.infer;
+type TenantConfig = typeof tenantConfig.infer;
+type OAuthProviderConfig = typeof oauthProviderConfig.infer;
+type OtpEmailConfig = typeof otpEmailConfig.infer;
+type OtpSmsConfig = typeof otpSmsConfig.infer;
+type OtpConfig = typeof otpConfig.infer;
+type MagicLinkConfig = typeof magicLinkConfig.infer;
+type TotpConfig = typeof totpConfig.infer;
+type WebAuthnConfig = typeof webauthnConfig.infer;
+type PasswordConfig = typeof passwordConfig.infer;
+type OAuthProvidersConfig = typeof oauthProvidersConfig.infer;
+type ProvidersConfig = typeof providersConfig.infer;
+type StorageConfig = typeof storageConfig.infer;
+type ParsAuthConfig = typeof parsAuthConfig.infer;
+
+/**
+ * @parsrun/types - Tenant Schemas
+ * Multi-tenant related validation schemas
+ */
+/** Tenant entity */
+declare const tenant: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    name: string;
+    status: "active" | "inactive" | "suspended" | "deleted";
+    insertedAt: string;
+    updatedAt: string;
+    slug?: string;
+    description?: string;
+    settings?: object;
+    metadata?: object;
+    logoUrl?: string;
+    primaryColor?: string;
+    timezone?: string;
+    locale?: string;
+    currency?: string;
+    deletedAt?: string;
+}, {}>;
+/** Tenant creation request */
+declare const createTenantRequest: arktype_internal_variants_object_ts.ObjectType<{
+    name: string;
+    slug?: string;
+    description?: string;
+    settings?: object;
+    logoUrl?: string;
+    primaryColor?: string;
+    timezone?: string;
+    locale?: string;
+    currency?: string;
+}, {}>;
+/** Tenant update request */
+declare const updateTenantRequest: arktype_internal_variants_object_ts.ObjectType<{
+    name?: string;
+    slug?: string;
+    description?: string;
+    settings?: object;
+    logoUrl?: string;
+    primaryColor?: string;
+    timezone?: string;
+    locale?: string;
+    currency?: string;
+    status?: "active" | "inactive" | "suspended" | "deleted";
+}, {}>;
+/** Tenant invite request */
+declare const inviteTenantMemberRequest: arktype_internal_variants_object_ts.ObjectType<{
+    email: string;
+    roleId: string;
+    accessLevel?: "full" | "limited" | "read_only";
+    expiresAt?: string;
+    message?: string;
+}, {}>;
+/** Tenant member list query */
+declare const tenantMemberListQuery: arktype_internal_variants_object_ts.ObjectType<{
+    page?: number;
+    limit?: number;
+    status?: "active" | "inactive" | "suspended" | "invited";
+    roleId?: string;
+    search?: string;
+}, {}>;
+/** Tenant switch request */
+declare const switchTenantRequest: arktype_internal_variants_object_ts.ObjectType<{
+    tenantId: string;
+}, {}>;
+type Tenant = typeof tenant.infer;
+type CreateTenantRequest = typeof createTenantRequest.infer;
+type UpdateTenantRequest = typeof updateTenantRequest.infer;
+type InviteTenantMemberRequest = typeof inviteTenantMemberRequest.infer;
+type TenantMemberListQuery = typeof tenantMemberListQuery.infer;
+type SwitchTenantRequest = typeof switchTenantRequest.infer;
+
+/**
+ * @parsrun/types - Email Schemas
+ * Email service validation schemas
+ */
+/** Email address with optional name */
+declare const emailAddress: arktype_internal_variants_object_ts.ObjectType<{
+    email: string;
+    name?: string;
+}, {}>;
+/** Simple email string or address object */
+declare const emailRecipient: arktype.BaseType<string | object, {}>;
+/** Email attachment */
+declare const emailAttachment: arktype_internal_variants_object_ts.ObjectType<{
+    filename: string;
+    content: string | object;
+    contentType?: string;
+    encoding?: "base64" | "utf-8" | "binary";
+    contentId?: string;
+    disposition?: "attachment" | "inline";
+}, {}>;
+/** Email options */
+declare const sendEmailOptions: arktype_internal_variants_object_ts.ObjectType<{
+    to: string | object | string[] | object[];
+    subject: string;
+    cc?: string | object | string[] | object[];
+    bcc?: string | object | string[] | object[];
+    from?: string | object;
+    replyTo?: string | object;
+    text?: string;
+    html?: string;
+    attachments?: {
+        filename: string;
+        content: string | object;
+        contentType?: string;
+        encoding?: "base64" | "utf-8" | "binary";
+        contentId?: string;
+        disposition?: "attachment" | "inline";
+    }[];
+    headers?: object;
+    priority?: "high" | "normal" | "low";
+    tags?: string[];
+    metadata?: object;
+}, {}>;
+/** Templated email options */
+declare const sendTemplateEmailOptions: arktype_internal_variants_object_ts.ObjectType<{
+    to: string | object | string[] | object[];
+    template: string;
+    cc?: string | object | string[] | object[];
+    bcc?: string | object | string[] | object[];
+    from?: string | object;
+    replyTo?: string | object;
+    data?: object;
+    attachments?: {
+        filename: string;
+        content: string | object;
+        contentType?: string;
+        encoding?: "base64" | "utf-8" | "binary";
+        contentId?: string;
+        disposition?: "attachment" | "inline";
+    }[];
+    headers?: object;
+    priority?: "high" | "normal" | "low";
+    tags?: string[];
+    metadata?: object;
+}, {}>;
+/** Email send result */
+declare const emailSendResult: arktype_internal_variants_object_ts.ObjectType<{
+    success: boolean;
+    messageId: string;
+    accepted?: string[];
+    rejected?: string[];
+    pending?: string[];
+}, {}>;
+/** SMTP config */
+declare const smtpConfig: arktype_internal_variants_object_ts.ObjectType<{
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth?: {
+        user: string;
+        pass: string;
+    };
+    tls?: object;
+}, {}>;
+/** Resend config */
+declare const resendConfig: arktype_internal_variants_object_ts.ObjectType<{
+    apiKey: string;
+    domain?: string;
+}, {}>;
+/** SendGrid config */
+declare const sendgridConfig: arktype_internal_variants_object_ts.ObjectType<{
+    apiKey: string;
+}, {}>;
+/** AWS SES config */
+declare const sesConfig: arktype_internal_variants_object_ts.ObjectType<{
+    region: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    endpoint?: string;
+}, {}>;
+/** Postmark config */
+declare const postmarkConfig: arktype_internal_variants_object_ts.ObjectType<{
+    serverToken: string;
+}, {}>;
+/** Email provider config */
+declare const emailConfig: arktype_internal_variants_object_ts.ObjectType<{
+    provider: "smtp" | "resend" | "sendgrid" | "ses" | "postmark" | "mailgun";
+    from?: string | object;
+    replyTo?: string | object;
+    smtp?: {
+        host: string;
+        port: number;
+        secure?: boolean;
+        auth?: {
+            user: string;
+            pass: string;
+        };
+        tls?: object;
+    };
+    resend?: {
+        apiKey: string;
+        domain?: string;
+    };
+    sendgrid?: {
+        apiKey: string;
+    };
+    ses?: {
+        region: string;
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        endpoint?: string;
+    };
+    postmark?: {
+        serverToken: string;
+    };
+    templates?: object;
+}, {}>;
+type EmailAddress = typeof emailAddress.infer;
+type EmailRecipient = typeof emailRecipient.infer;
+type EmailAttachment = typeof emailAttachment.infer;
+type SendEmailOptions = typeof sendEmailOptions.infer;
+type SendTemplateEmailOptions = typeof sendTemplateEmailOptions.infer;
+type EmailSendResult = typeof emailSendResult.infer;
+type SmtpConfig = typeof smtpConfig.infer;
+type ResendConfig = typeof resendConfig.infer;
+type SendgridConfig = typeof sendgridConfig.infer;
+type SesConfig = typeof sesConfig.infer;
+type PostmarkConfig = typeof postmarkConfig.infer;
+type EmailConfig = typeof emailConfig.infer;
+
+/**
+ * @parsrun/types - Storage Schemas
+ * File storage validation schemas
+ */
+/** File metadata */
+declare const fileMetadata: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    filename: string;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    bucket: string;
+    insertedAt: string;
+    updatedAt: string;
+    path?: string;
+    url?: string;
+    etag?: string;
+    metadata?: object;
+    uploadedBy?: string;
+    tenantId?: string;
+    deletedAt?: string;
+}, {}>;
+/** Upload options */
+declare const uploadOptions: arktype_internal_variants_object_ts.ObjectType<{
+    path?: string;
+    filename?: string;
+    contentType?: string;
+    metadata?: object;
+    acl?: "private" | "public-read" | "authenticated-read";
+    cacheControl?: string;
+    contentDisposition?: string;
+}, {}>;
+/** Signed URL options */
+declare const signedUrlOptions: arktype_internal_variants_object_ts.ObjectType<{
+    expiresIn?: number;
+    method?: "GET" | "PUT";
+    contentType?: string;
+    responseContentType?: string;
+    responseContentDisposition?: string;
+}, {}>;
+/** List files options */
+declare const listFilesOptions: arktype_internal_variants_object_ts.ObjectType<{
+    prefix?: string;
+    limit?: number;
+    cursor?: string;
+    delimiter?: string;
+}, {}>;
+/** List files result */
+declare const listFilesResult: arktype_internal_variants_object_ts.ObjectType<{
+    files: {
+        id: string;
+        filename: string;
+        originalName: string;
+        mimeType: string;
+        size: number;
+        bucket: string;
+        insertedAt: string;
+        updatedAt: string;
+        path?: string;
+        url?: string;
+        etag?: string;
+        metadata?: object;
+        uploadedBy?: string;
+        tenantId?: string;
+        deletedAt?: string;
+    }[];
+    hasMore: boolean;
+    nextCursor?: string;
+}, {}>;
+/** Local storage config */
+declare const localStorageConfig: arktype_internal_variants_object_ts.ObjectType<{
+    basePath: string;
+    baseUrl?: string;
+    permissions?: number;
+}, {}>;
+/** S3 storage config */
+declare const s3StorageConfig: arktype_internal_variants_object_ts.ObjectType<{
+    bucket: string;
+    region: string;
+    endpoint?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    forcePathStyle?: boolean;
+    acl?: "private" | "public-read" | "authenticated-read";
+}, {}>;
+/** Cloudflare R2 config */
+declare const r2StorageConfig: arktype_internal_variants_object_ts.ObjectType<{
+    accountId: string;
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    publicUrl?: string;
+}, {}>;
+/** GCS config */
+declare const gcsStorageConfig: arktype_internal_variants_object_ts.ObjectType<{
+    bucket: string;
+    projectId?: string;
+    credentials?: object;
+    keyFilename?: string;
+}, {}>;
+/** Storage config */
+declare const storageProviderConfig: arktype_internal_variants_object_ts.ObjectType<{
+    provider: "local" | "s3" | "r2" | "gcs" | "azure";
+    defaultBucket?: string;
+    local?: {
+        basePath: string;
+        baseUrl?: string;
+        permissions?: number;
+    };
+    s3?: {
+        bucket: string;
+        region: string;
+        endpoint?: string;
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        forcePathStyle?: boolean;
+        acl?: "private" | "public-read" | "authenticated-read";
+    };
+    r2?: {
+        accountId: string;
+        bucket: string;
+        accessKeyId: string;
+        secretAccessKey: string;
+        publicUrl?: string;
+    };
+    gcs?: {
+        bucket: string;
+        projectId?: string;
+        credentials?: object;
+        keyFilename?: string;
+    };
+}, {}>;
+type FileMetadata = typeof fileMetadata.infer;
+type UploadOptions = typeof uploadOptions.infer;
+type SignedUrlOptions = typeof signedUrlOptions.infer;
+type ListFilesOptions = typeof listFilesOptions.infer;
+type ListFilesResult = typeof listFilesResult.infer;
+type LocalStorageConfig = typeof localStorageConfig.infer;
+type S3StorageConfig = typeof s3StorageConfig.infer;
+type R2StorageConfig = typeof r2StorageConfig.infer;
+type GcsStorageConfig = typeof gcsStorageConfig.infer;
+type StorageProviderConfig = typeof storageProviderConfig.infer;
+
+/**
+ * @parsrun/types - Queue Schemas
+ * Job queue validation schemas
+ */
+/** Job status */
+declare const jobStatus: arktype_internal_variants_string_ts.StringType<"active" | "pending" | "completed" | "failed" | "delayed" | "paused", {}>;
+/** Job entity */
+declare const job: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    queue: string;
+    name: string;
+    data: unknown;
+    status: "active" | "pending" | "completed" | "failed" | "delayed" | "paused";
+    attempts: number;
+    maxAttempts: number;
+    insertedAt: string;
+    updatedAt: string;
+    result?: unknown;
+    error?: string;
+    priority?: number;
+    delay?: number;
+    progress?: number;
+    startedAt?: string;
+    completedAt?: string;
+    failedAt?: string;
+    processedBy?: string;
+}, {}>;
+/** Job options */
+declare const jobOptions: arktype_internal_variants_object_ts.ObjectType<{
+    priority?: number;
+    delay?: number;
+    attempts?: number;
+    backoff?: {
+        type: "fixed" | "exponential";
+        delay?: number;
+    };
+    timeout?: number;
+    removeOnComplete?: number | boolean;
+    removeOnFail?: number | boolean;
+    repeat?: {
+        pattern?: string;
+        every?: number;
+        limit?: number;
+        tz?: string;
+    };
+}, {}>;
+/** Add job request */
+declare const addJobRequest: arktype_internal_variants_object_ts.ObjectType<{
+    name: string;
+    data: unknown;
+    options?: {
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+        backoff?: {
+            type: "fixed" | "exponential";
+            delay?: number;
+        };
+        timeout?: number;
+        removeOnComplete?: number | boolean;
+        removeOnFail?: number | boolean;
+        repeat?: {
+            pattern?: string;
+            every?: number;
+            limit?: number;
+            tz?: string;
+        };
+    };
+}, {}>;
+/** Job progress update */
+declare const jobProgressUpdate: arktype_internal_variants_object_ts.ObjectType<{
+    progress: number;
+    message?: string;
+    data?: unknown;
+}, {}>;
+/** Queue stats */
+declare const queueStats: arktype_internal_variants_object_ts.ObjectType<{
+    name: string;
+    pending: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    paused: boolean;
+}, {}>;
+/** Queue list options */
+declare const queueListOptions: arktype_internal_variants_object_ts.ObjectType<{
+    status?: "active" | "pending" | "completed" | "failed" | "delayed" | "paused";
+    start?: number;
+    end?: number;
+    order?: "asc" | "desc";
+}, {}>;
+/** Redis queue config */
+declare const redisQueueConfig: arktype_internal_variants_object_ts.ObjectType<{
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    url?: string;
+    tls?: boolean | object;
+}, {}>;
+/** Queue worker options */
+declare const workerOptions: arktype_internal_variants_object_ts.ObjectType<{
+    concurrency?: number;
+    limiter?: {
+        max: number;
+        duration: number;
+    };
+    lockDuration?: number;
+    lockRenewTime?: number;
+    stalledInterval?: number;
+    maxStalledCount?: number;
+}, {}>;
+/** Queue config */
+declare const queueConfig: arktype_internal_variants_object_ts.ObjectType<{
+    provider: "memory" | "bullmq" | "sqs" | "rabbitmq";
+    defaultJobOptions?: {
+        priority?: number;
+        delay?: number;
+        attempts?: number;
+        backoff?: {
+            type: "fixed" | "exponential";
+            delay?: number;
+        };
+        timeout?: number;
+        removeOnComplete?: number | boolean;
+        removeOnFail?: number | boolean;
+        repeat?: {
+            pattern?: string;
+            every?: number;
+            limit?: number;
+            tz?: string;
+        };
+    };
+    redis?: {
+        host?: string;
+        port?: number;
+        password?: string;
+        db?: number;
+        url?: string;
+        tls?: boolean | object;
+    };
+    prefix?: string;
+    worker?: {
+        concurrency?: number;
+        limiter?: {
+            max: number;
+            duration: number;
+        };
+        lockDuration?: number;
+        lockRenewTime?: number;
+        stalledInterval?: number;
+        maxStalledCount?: number;
+    };
+}, {}>;
+type JobStatus = typeof jobStatus.infer;
+type Job = typeof job.infer;
+type JobOptions = typeof jobOptions.infer;
+type AddJobRequest = typeof addJobRequest.infer;
+type JobProgressUpdate = typeof jobProgressUpdate.infer;
+type QueueStats = typeof queueStats.infer;
+type QueueListOptions = typeof queueListOptions.infer;
+type RedisQueueConfig = typeof redisQueueConfig.infer;
+type WorkerOptions = typeof workerOptions.infer;
+type QueueConfig = typeof queueConfig.infer;
+
+/**
+ * @parsrun/types - Cache Schemas
+ * Caching validation schemas
+ */
+/** Cache set options */
+declare const cacheSetOptions: arktype_internal_variants_object_ts.ObjectType<{
+    ttl?: number;
+    tags?: string[];
+    metadata?: object;
+}, {}>;
+/** Cache get result */
+declare const cacheGetResult: arktype_internal_variants_object_ts.ObjectType<{
+    value: unknown;
+    ttl?: number;
+    createdAt?: number;
+    tags?: string[];
+}, {}>;
+/** Cache stats */
+declare const cacheStats: arktype_internal_variants_object_ts.ObjectType<{
+    hits: number;
+    misses: number;
+    keys: number;
+    memory?: number;
+}, {}>;
+/** Memory cache config */
+declare const memoryCacheConfig: arktype_internal_variants_object_ts.ObjectType<{
+    maxSize?: number;
+    ttl?: number;
+    checkInterval?: number;
+    stale?: boolean;
+}, {}>;
+/** Redis cache config */
+declare const redisCacheConfig: arktype_internal_variants_object_ts.ObjectType<{
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    url?: string;
+    tls?: boolean | object;
+    keyPrefix?: string;
+    ttl?: number;
+}, {}>;
+/** Upstash cache config */
+declare const upstashCacheConfig: arktype_internal_variants_object_ts.ObjectType<{
+    url: string;
+    token: string;
+    keyPrefix?: string;
+    ttl?: number;
+}, {}>;
+/** Cloudflare KV config */
+declare const cloudflareKvConfig: arktype_internal_variants_object_ts.ObjectType<{
+    namespaceId: string;
+    accountId?: string;
+    apiToken?: string;
+    keyPrefix?: string;
+}, {}>;
+/** Multi-tier cache config */
+declare const multiTierCacheConfig: arktype_internal_variants_object_ts.ObjectType<{
+    tiers: {
+        type: "redis" | "upstash" | "memory" | "cloudflare-kv";
+        priority?: number;
+        ttl?: number;
+        config?: object;
+    }[];
+    writeThrough?: boolean;
+    readThrough?: boolean;
+}, {}>;
+/** Cache config */
+declare const cacheConfig: arktype_internal_variants_object_ts.ObjectType<{
+    provider: "redis" | "upstash" | "memory" | "cloudflare-kv" | "multi-tier";
+    ttl?: number;
+    keyPrefix?: string;
+    memory?: {
+        maxSize?: number;
+        ttl?: number;
+        checkInterval?: number;
+        stale?: boolean;
+    };
+    redis?: {
+        host?: string;
+        port?: number;
+        password?: string;
+        db?: number;
+        url?: string;
+        tls?: boolean | object;
+        keyPrefix?: string;
+        ttl?: number;
+    };
+    upstash?: {
+        url: string;
+        token: string;
+        keyPrefix?: string;
+        ttl?: number;
+    };
+    cloudflareKv?: {
+        namespaceId: string;
+        accountId?: string;
+        apiToken?: string;
+        keyPrefix?: string;
+    };
+    multiTier?: {
+        tiers: {
+            type: "redis" | "upstash" | "memory" | "cloudflare-kv";
+            priority?: number;
+            ttl?: number;
+            config?: object;
+        }[];
+        writeThrough?: boolean;
+        readThrough?: boolean;
+    };
+}, {}>;
+type CacheSetOptions = typeof cacheSetOptions.infer;
+type CacheGetResult = typeof cacheGetResult.infer;
+type CacheStats = typeof cacheStats.infer;
+type MemoryCacheConfig = typeof memoryCacheConfig.infer;
+type RedisCacheConfig = typeof redisCacheConfig.infer;
+type UpstashCacheConfig = typeof upstashCacheConfig.infer;
+type CloudflareKvConfig = typeof cloudflareKvConfig.infer;
+type MultiTierCacheConfig = typeof multiTierCacheConfig.infer;
+type CacheConfig = typeof cacheConfig.infer;
+
+/**
+ * @parsrun/types - Payments Schemas
+ * Payment provider validation schemas
+ */
+/** Currency code (ISO 4217) */
+declare const currencyCode: arktype_internal_variants_string_ts.StringType<string, {}>;
+/** Money amount with currency */
+declare const money: arktype_internal_variants_object_ts.ObjectType<{
+    amount: number;
+    currency: string;
+}, {}>;
+/** Payment customer */
+declare const paymentCustomer: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    email: string;
+    insertedAt: string;
+    updatedAt: string;
+    externalId?: string;
+    name?: string;
+    phone?: string;
+    metadata?: object;
+}, {}>;
+/** Create customer request */
+declare const createCustomerRequest: arktype_internal_variants_object_ts.ObjectType<{
+    email: string;
+    name?: string;
+    phone?: string;
+    metadata?: object;
+}, {}>;
+/** Card details */
+declare const cardDetails: arktype_internal_variants_object_ts.ObjectType<{
+    brand: string;
+    last4: string;
+    expMonth: number;
+    expYear: number;
+    fingerprint?: string;
+}, {}>;
+/** Payment method */
+declare const paymentMethod: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    customerId: string;
+    type: "crypto" | "card" | "bank_account" | "paypal" | "other";
+    isDefault: boolean;
+    insertedAt: string;
+    updatedAt: string;
+    externalId?: string;
+    card?: {
+        brand: string;
+        last4: string;
+        expMonth: number;
+        expYear: number;
+        fingerprint?: string;
+    };
+    metadata?: object;
+}, {}>;
+/** Payment intent status */
+declare const paymentIntentStatus: arktype_internal_variants_string_ts.StringType<"failed" | "created" | "processing" | "requires_action" | "succeeded" | "canceled", {}>;
+/** Payment intent */
+declare const paymentIntent: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    customerId: string;
+    amount: number;
+    currency: string;
+    status: "failed" | "created" | "processing" | "requires_action" | "succeeded" | "canceled";
+    insertedAt: string;
+    updatedAt: string;
+    externalId?: string;
+    paymentMethodId?: string;
+    description?: string;
+    metadata?: object;
+    clientSecret?: string;
+    failureReason?: string;
+}, {}>;
+/** Create payment intent request */
+declare const createPaymentIntentRequest: arktype_internal_variants_object_ts.ObjectType<{
+    customerId: string;
+    amount: number;
+    currency: string;
+    paymentMethodId?: string;
+    description?: string;
+    metadata?: object;
+    confirm?: boolean;
+    returnUrl?: string;
+}, {}>;
+/** Subscription status */
+declare const subscriptionStatus: arktype_internal_variants_string_ts.StringType<"active" | "paused" | "canceled" | "past_due" | "incomplete" | "incomplete_expired" | "trialing", {}>;
+/** Price interval */
+declare const priceInterval: arktype_internal_variants_string_ts.StringType<"day" | "week" | "month" | "year", {}>;
+/** Price */
+declare const price: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    productId: string;
+    amount: number;
+    currency: string;
+    interval: "day" | "week" | "month" | "year";
+    isActive: boolean;
+    externalId?: string;
+    intervalCount?: number;
+    trialDays?: number;
+    metadata?: object;
+}, {}>;
+/** Subscription */
+declare const subscription: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    customerId: string;
+    priceId: string;
+    status: "active" | "paused" | "canceled" | "past_due" | "incomplete" | "incomplete_expired" | "trialing";
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    insertedAt: string;
+    updatedAt: string;
+    externalId?: string;
+    cancelAt?: string;
+    canceledAt?: string;
+    trialStart?: string;
+    trialEnd?: string;
+    metadata?: object;
+}, {}>;
+/** Create subscription request */
+declare const createSubscriptionRequest: arktype_internal_variants_object_ts.ObjectType<{
+    customerId: string;
+    priceId: string;
+    paymentMethodId?: string;
+    trialDays?: number;
+    metadata?: object;
+}, {}>;
+/** Refund status */
+declare const refundStatus: arktype_internal_variants_string_ts.StringType<"pending" | "failed" | "succeeded" | "canceled", {}>;
+/** Refund */
+declare const refund: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    paymentIntentId: string;
+    amount: number;
+    currency: string;
+    status: "pending" | "failed" | "succeeded" | "canceled";
+    insertedAt: string;
+    updatedAt: string;
+    externalId?: string;
+    reason?: string;
+    metadata?: object;
+}, {}>;
+/** Create refund request */
+declare const createRefundRequest: arktype_internal_variants_object_ts.ObjectType<{
+    paymentIntentId: string;
+    amount?: number;
+    reason?: string;
+    metadata?: object;
+}, {}>;
+/** Webhook event types */
+declare const webhookEventType: arktype_internal_variants_string_ts.StringType<"payment.succeeded" | "payment.failed" | "subscription.created" | "subscription.updated" | "subscription.canceled" | "refund.created" | "customer.created" | "customer.updated", {}>;
+/** Webhook event */
+declare const webhookEvent: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+    type: "payment.succeeded" | "payment.failed" | "subscription.created" | "subscription.updated" | "subscription.canceled" | "refund.created" | "customer.created" | "customer.updated";
+    data: object;
+    createdAt: string;
+    livemode?: boolean;
+    apiVersion?: string;
+}, {}>;
+/** Stripe config */
+declare const stripeConfig: arktype_internal_variants_object_ts.ObjectType<{
+    secretKey: string;
+    publishableKey?: string;
+    webhookSecret?: string;
+    apiVersion?: string;
+}, {}>;
+/** Paddle config */
+declare const paddleConfig: arktype_internal_variants_object_ts.ObjectType<{
+    vendorId: string;
+    vendorAuthCode: string;
+    publicKey?: string;
+    webhookSecret?: string;
+    sandbox?: boolean;
+}, {}>;
+/** iyzico config */
+declare const iyzicoConfig: arktype_internal_variants_object_ts.ObjectType<{
+    apiKey: string;
+    secretKey: string;
+    baseUrl: string;
+    sandbox?: boolean;
+}, {}>;
+/** Payments config */
+declare const paymentsConfig: arktype_internal_variants_object_ts.ObjectType<{
+    provider: "stripe" | "paddle" | "iyzico";
+    currency?: string;
+    stripe?: {
+        secretKey: string;
+        publishableKey?: string;
+        webhookSecret?: string;
+        apiVersion?: string;
+    };
+    paddle?: {
+        vendorId: string;
+        vendorAuthCode: string;
+        publicKey?: string;
+        webhookSecret?: string;
+        sandbox?: boolean;
+    };
+    iyzico?: {
+        apiKey: string;
+        secretKey: string;
+        baseUrl: string;
+        sandbox?: boolean;
+    };
+    webhookPath?: string;
+}, {}>;
+type CurrencyCode = typeof currencyCode.infer;
+type Money = typeof money.infer;
+type PaymentCustomer = typeof paymentCustomer.infer;
+type CreateCustomerRequest = typeof createCustomerRequest.infer;
+type CardDetails = typeof cardDetails.infer;
+type PaymentMethod = typeof paymentMethod.infer;
+type PaymentIntentStatus = typeof paymentIntentStatus.infer;
+type PaymentIntent = typeof paymentIntent.infer;
+type CreatePaymentIntentRequest = typeof createPaymentIntentRequest.infer;
+type SubscriptionStatus = typeof subscriptionStatus.infer;
+type PriceInterval = typeof priceInterval.infer;
+type Price = typeof price.infer;
+type Subscription = typeof subscription.infer;
+type CreateSubscriptionRequest = typeof createSubscriptionRequest.infer;
+type RefundStatus = typeof refundStatus.infer;
+type Refund = typeof refund.infer;
+type CreateRefundRequest = typeof createRefundRequest.infer;
+type WebhookEventType = typeof webhookEventType.infer;
+type WebhookEvent = typeof webhookEvent.infer;
+type StripeConfig = typeof stripeConfig.infer;
+type PaddleConfig = typeof paddleConfig.infer;
+type IyzicoConfig = typeof iyzicoConfig.infer;
+type PaymentsConfig = typeof paymentsConfig.infer;
+
+/**
+ * @parsrun/types - Server Schemas
+ * HTTP server validation schemas
+ */
+/** UUID path parameter */
+declare const uuidParam: arktype_internal_variants_object_ts.ObjectType<{
+    id: string;
+}, {}>;
+/** Standard pagination query */
+declare const paginationQuery: arktype_internal_variants_object_ts.ObjectType<{
+    page?: string;
+    limit?: string;
+    orderBy?: string;
+    orderDirection?: "asc" | "desc";
+}, {}>;
+/** Cursor pagination query */
+declare const cursorPaginationQuery: arktype_internal_variants_object_ts.ObjectType<{
+    cursor?: string;
+    limit?: string;
+    direction?: "forward" | "backward";
+}, {}>;
+/** Search query */
+declare const searchQuery: arktype_internal_variants_object_ts.ObjectType<{
+    q?: string;
+    search?: string;
+    filter?: string;
+}, {}>;
+/** Date range query */
+declare const dateRangeQuery: arktype_internal_variants_object_ts.ObjectType<{
+    startDate?: string;
+    endDate?: string;
+}, {}>;
+/** Health check response */
+declare const healthResponse: arktype_internal_variants_object_ts.ObjectType<{
+    status: "healthy" | "degraded" | "unhealthy";
+    timestamp: string;
+    checks: {
+        name: string;
+        status: "healthy" | "degraded" | "unhealthy";
+        message?: string;
+        latency?: number;
+    }[];
+    version?: string;
+    uptime?: number;
+}, {}>;
+/** API info response */
+declare const apiInfoResponse: arktype_internal_variants_object_ts.ObjectType<{
+    name: string;
+    version: string;
+    description?: string;
+    environment?: string;
+    documentation?: string;
+}, {}>;
+/** CORS config */
+declare const corsConfig: arktype_internal_variants_object_ts.ObjectType<{
+    origin?: string | boolean | Function | string[];
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}, {}>;
+/** Server rate limit config */
+declare const serverRateLimitConfig: arktype_internal_variants_object_ts.ObjectType<{
+    enabled?: boolean;
+    windowMs?: number;
+    max?: number;
+    keyGenerator?: Function;
+    skip?: Function;
+    message?: string;
+}, {}>;
+/** Logger config */
+declare const loggerConfig: arktype_internal_variants_object_ts.ObjectType<{
+    level?: "error" | "debug" | "info" | "warn";
+    format?: "json" | "pretty" | "combined" | "short";
+    redact?: string[];
+    timestamp?: boolean;
+}, {}>;
+/** Server config */
+declare const serverConfig: arktype_internal_variants_object_ts.ObjectType<{
+    port?: number;
+    host?: string;
+    basePath?: string;
+    cors?: {
+        origin?: string | boolean | Function | string[];
+        methods?: string[];
+        allowedHeaders?: string[];
+        exposedHeaders?: string[];
+        credentials?: boolean;
+        maxAge?: number;
+    };
+    rateLimit?: {
+        enabled?: boolean;
+        windowMs?: number;
+        max?: number;
+        keyGenerator?: Function;
+        skip?: Function;
+        message?: string;
+    };
+    logger?: {
+        level?: "error" | "debug" | "info" | "warn";
+        format?: "json" | "pretty" | "combined" | "short";
+        redact?: string[];
+        timestamp?: boolean;
+    };
+    trustProxy?: boolean;
+    strictRouting?: boolean;
+    caseSensitiveRouting?: boolean;
+}, {}>;
+/** Auth context (after auth middleware) */
+declare const authContext: arktype_internal_variants_object_ts.ObjectType<{
+    userId: string;
+    tenantId?: string;
+    sessionId?: string;
+    roles?: string[];
+    permissions?: string[];
+}, {}>;
+/** Request context */
+declare const requestContext: arktype_internal_variants_object_ts.ObjectType<{
+    requestId: string;
+    startTime?: number;
+    ip?: string;
+    userAgent?: string;
+    auth?: {
+        userId: string;
+        tenantId?: string;
+        sessionId?: string;
+        roles?: string[];
+        permissions?: string[];
+    };
+}, {}>;
+type UuidParam = typeof uuidParam.infer;
+type PaginationQuery = typeof paginationQuery.infer;
+type CursorPaginationQuery = typeof cursorPaginationQuery.infer;
+type SearchQuery = typeof searchQuery.infer;
+type DateRangeQuery = typeof dateRangeQuery.infer;
+type HealthResponse = typeof healthResponse.infer;
+type ApiInfoResponse = typeof apiInfoResponse.infer;
+type CorsConfig = typeof corsConfig.infer;
+type ServerRateLimitConfig = typeof serverRateLimitConfig.infer;
+type LoggerConfig = typeof loggerConfig.infer;
+type ServerConfig = typeof serverConfig.infer;
+type AuthContext = typeof authContext.infer;
+type RequestContext = typeof requestContext.infer;
+
+/**
+ * @parsrun/types
+ * Core types and validation schemas for Pars framework
+ *
+ * Uses ArkType for runtime validation + type inference
+ *
+ * @example
+ * ```typescript
+ * import { user, User, validateWithSchema } from '@parsrun/types';
+ *
+ * // Runtime validation
+ * const result = user(data);
+ * if (result instanceof type.errors) {
+ *   console.error(result.summary);
+ * }
+ *
+ * // Type inference
+ * const userData: User = result;
+ * ```
+ */
+
+/**
+ * Validate data against an ArkType schema
+ * Returns the validated data or throws an error
+ *
+ * @example
+ * ```typescript
+ * const userData = validateWithSchema(user, input);
+ * ```
+ */
+declare function validateWithSchema<T extends Type>(schema: T, data: unknown): T["infer"];
+/**
+ * Safely validate data against an ArkType schema
+ * Returns a result object with success/error
+ *
+ * @example
+ * ```typescript
+ * const result = safeValidate(user, input);
+ * if (result.success) {
+ *   console.log(result.data);
+ * } else {
+ *   console.error(result.errors);
+ * }
+ * ```
+ */
+declare function safeValidate<T extends Type>(schema: T, data: unknown): {
+    success: true;
+    data: T["infer"];
+} | {
+    success: false;
+    errors: string[];
+};
+/**
+ * Check if data matches an ArkType schema (type guard)
+ *
+ * @example
+ * ```typescript
+ * if (isValid(user, input)) {
+ *   // input is typed as User
+ * }
+ * ```
+ */
+declare function isValid<T extends Type>(schema: T, data: unknown): data is T["infer"];
+/**
+ * Format ArkType errors to a user-friendly object
+ *
+ * @example
+ * ```typescript
+ * const result = user(input);
+ * if (result instanceof type.errors) {
+ *   const formatted = formatErrors(result);
+ *   // { email: "must be a valid email", ... }
+ * }
+ * ```
+ */
+declare function formatErrors(errors: type.errors): Record<string, string>;
+
+export { type AddJobRequest, type ApiCursorPaginatedResponse, type ApiErrorResponse, type ApiInfoResponse, type ApiPaginatedResponse, type ApiResponse, type AuthContext, type AuthMethod, type CSRFTokenRequest, type CacheConfig, type CacheGetResult, type CacheSetOptions, type CacheStats, type CardDetails, type CheckVerificationStatusRequest, type CheckVerificationStatusResponse, type CloudflareKvConfig, type CookieConfig, type CorsConfig, type CreateCustomerRequest, type CreatePaymentIntentRequest, type CreateRefundRequest, type CreateSubscriptionRequest, type CreateTenantRequest, type CsrfConfig, type CurrencyCode, type CurrentUserResponse, type CurrentUserResponseData, type CursorPagination, type CursorPaginationMeta, type CursorPaginationQuery, type DateRangeQuery, type Email, type EmailAddress, type EmailAttachment, type EmailConfig, type EmailRecipient, type EmailSendResult, type ErrorResponse, type FileMetadata, type GcsStorageConfig, type HealthResponse, type InviteTenantMemberRequest, type IyzicoConfig, type Job, type JobOptions, type JobProgressUpdate, type JobStatus, type JwtConfig, type JwtPayload, type ListFilesOptions, type ListFilesResult, type LocalStorageConfig, type LockoutConfig, type LoggerConfig, type LoginResponse, type LoginResponseData, type LogoutRequest, type MagicLinkConfig, type MemoryCacheConfig, type Money, type MultiTierCacheConfig, type NonEmptyString, type NonNegativeInt, type OAuthProviderConfig, type OAuthProvidersConfig, type OtpConfig, type OtpEmailConfig, type OtpSmsConfig, type PaddleConfig, type Pagination, type PaginationMeta, type PaginationQuery, type ParsAuthConfig, type ParsError, type PasswordConfig, type PaymentCustomer, type PaymentIntent, type PaymentIntentStatus, type PaymentMethod, type PaymentsConfig, type Permission, type PermissionCheck, type PositiveInt, type PostmarkConfig, type Price, type PriceInterval, type ProvidersConfig, type QueueConfig, type QueueListOptions, type QueueStats, type R2StorageConfig, type RateLimitConfig, type RedisCacheConfig, type RedisQueueConfig, type RefreshTokenRequest, type Refund, type RefundStatus, type RequestContext, type RequestOTPRequest, type RequestOTPResponse, type ResendConfig, type ResendOTPRequest, type RevokeAllSessionsRequest, type RevokeAllSessionsResponse, type RevokeSessionRequest, type Role, type S3StorageConfig, type SearchQuery, type SecurityConfig, type SendEmailOptions, type SendTemplateEmailOptions, type SendVerificationEmailRequest, type SendgridConfig, type ServerConfig, type ServerRateLimitConfig, type SesConfig, type Session, type SessionConfig, type SessionStatus, type SignedUrlOptions, type SmtpConfig, type Status, type StorageConfig, type StorageProviderConfig, type StripeConfig, type Subscription, type SubscriptionStatus, type SwitchTenantRequest, type Tenant, type TenantConfig, type TenantMemberListQuery, type TenantMembership, type Timestamp, type TokenInfo, type TotpConfig, type UUID, type UpdateTenantRequest, type UploadOptions, type UpstashCacheConfig, type Url, type User, type UuidParam, type ValidationErrorDetail, type VerifyEmailRequest, type VerifyOTPRequest, type WebAuthnConfig, type WebhookEvent, type WebhookEventType, type WorkerOptions, addJobRequest, apiInfoResponse, authContext, authMethod, cacheConfig, cacheGetResult, cacheSetOptions, cacheStats, cardDetails, checkVerificationStatusRequest, checkVerificationStatusResponse, cloudflareKvConfig, cookieConfig, corsConfig, createCustomerRequest, createPaymentIntentRequest, createRefundRequest, createSubscriptionRequest, createTenantRequest, csrfConfig, csrfTokenRequest, currencyCode, currentUserResponse, currentUserResponseData, cursorPaginatedResponse, cursorPagination, cursorPaginationMeta, cursorPaginationQuery, dateRangeQuery, email, emailAddress, emailAttachment, emailConfig, emailRecipient, emailSendResult, errorResponse, fileMetadata, formatErrors, gcsStorageConfig, healthResponse, inviteTenantMemberRequest, isValid, iyzicoConfig, job, jobOptions, jobProgressUpdate, jobStatus, jwtConfig, jwtPayload, listFilesOptions, listFilesResult, localStorageConfig, lockoutConfig, loggerConfig, loginResponse, loginResponseData, logoutRequest, magicLinkConfig, memoryCacheConfig, money, multiTierCacheConfig, nonEmptyString, nonNegativeInt, oauthProviderConfig, oauthProvidersConfig, otpConfig, otpEmailConfig, otpSmsConfig, paddleConfig, paginatedResponse, pagination, paginationMeta, paginationQuery, parsAuthConfig, parsError, passwordConfig, paymentCustomer, paymentIntent, paymentIntentStatus, paymentMethod, paymentsConfig, permission, permissionCheck, positiveInt, postmarkConfig, price, priceInterval, providersConfig, queueConfig, queueListOptions, queueStats, r2StorageConfig, rateLimitConfig, redisCacheConfig, redisQueueConfig, refreshTokenRequest, refund, refundStatus, requestContext, requestOTPRequest, requestOTPResponse, resendConfig, resendOTPRequest, revokeAllSessionsRequest, revokeAllSessionsResponse, revokeSessionRequest, role, s3StorageConfig, safeValidate, searchQuery, securityConfig, sendEmailOptions, sendTemplateEmailOptions, sendVerificationEmailRequest, sendgridConfig, serverConfig, serverRateLimitConfig, sesConfig, session, sessionConfig, sessionStatus, signedUrlOptions, smtpConfig, status, storageConfig, storageProviderConfig, stripeConfig, subscription, subscriptionStatus, successResponse, switchTenantRequest, tenant, tenantConfig, tenantMemberListQuery, tenantMembership, timestamp, tokenInfo, totpConfig, updateTenantRequest, uploadOptions, upstashCacheConfig, url, user, uuid, uuidParam, validateWithSchema, validationErrorDetail, verifyEmailRequest, verifyOTPRequest, webauthnConfig, webhookEvent, webhookEventType, workerOptions };