@zuzjs/flare 0.2.13 → 0.2.15

package/dist/index-DQHYN410.d.cts

@@ -0,0 +1,1322 @@
+import { AuthToken } from '@zuzjs/auth';
+
+/**
+ * Client Configuration
+ */
+interface FlareConfig {
+    /** Base URL for the Flare API. */
+    endpoint: string;
+    /**
+     * Optional HTTP base URL for auth API calls.
+     * When set, all auth HTTP calls go through this base instead of calling
+     * Flare directly. Use this to route calls through a Next.js proxy so CSRF
+     * is handled entirely server-side.
+     * Example: '/api/flare'  (relative, browser resolves against current origin)
+     */
+    httpBase?: string;
+    /**
+     * WebSocket path used for realtime transport.
+     * Defaults to '/' for backward compatibility.
+     */
+    wsPath?: string;
+    /** Unique identifier for the application. */
+    appId: string;
+    /** API key for the application. */
+    apiKey?: string;
+    /**
+     * Request content type for credential auth endpoints (/auth/token, /auth/register).
+     * Defaults to OAuth-compatible form encoding.
+     */
+    authRequestContentType?: "application/x-www-form-urlencoded" | "application/json";
+    /**
+     * Controls how onAuthStateChanged initializes auth in browser runtime.
+     * - `refresh` (default): attempt /auth/refresh once in httpBase mode.
+     * - `none`: skip automatic refresh bootstrap; listeners receive current in-memory state only.
+     */
+    authBootstrapMode?: "refresh" | "none";
+    /** Public key for the application. */
+    publicKey?: string;
+    /** Whether to automatically reconnect on connection loss. */
+    autoReconnect?: boolean;
+    /** Delay between reconnection attempts in milliseconds. */
+    reconnectDelay?: number;
+    /** Maximum delay between reconnection attempts in milliseconds. */
+    maxReconnectDelay?: number;
+    /** Enable or disable debug mode. */
+    debug?: boolean;
+    /** Enable or disable request timing. */
+    requestTiming?: boolean;
+    /** Connection timeout in milliseconds. */
+    connectionTimeout?: number;
+    /** Enable automatic push notification registration on supported platforms. */
+    pushNotifications?: boolean;
+    /**
+     * Optional per-collection mapper registry for shaping inbound data.
+     *
+     * Keys can be:
+     * - base collection names (e.g. "boards")
+     * - join aliases (`join(..., { as: "team" })` => "team")
+     */
+    dataMapper?: DataMapperRegistry;
+}
+type DataMapperFn<TRow = any, TMapped = any> = (row: TRow) => TMapped;
+type DataMapperRegistry = Record<string, DataMapperFn<any, any>>;
+type FlareAuthProviderId = "credentials" | "anonymous" | "google" | "facebook" | "github" | "dropbox" | "apple" | "twitter";
+interface FlareAuthProviderPublicConfig {
+    enabled: boolean;
+    clientId?: string;
+    scopes?: string[];
+}
+interface FlareAuthConfig {
+    appId: string;
+    enabled: boolean;
+    needsEmailVerification?: boolean;
+    autoSendVerificationEmail?: boolean;
+    redirectUri?: string;
+    csrfToken?: string;
+    cookie?: {
+        accessTokenName?: string;
+        refreshTokenName?: string;
+        csrfTokenName?: string;
+        domain?: string;
+        path?: string;
+        secure?: boolean;
+        sameSite?: "Lax" | "Strict" | "None";
+        accessTokenMaxAge?: number;
+        refreshTokenMaxAge?: number;
+        csrfTokenMaxAge?: number;
+    };
+    providers: Record<FlareAuthProviderId, FlareAuthProviderPublicConfig>;
+}
+interface FlareAuthSession {
+    uid: string;
+    accessToken: string;
+    refreshToken: string | null;
+    provider?: string;
+    email?: string | null;
+    emailVerified?: boolean;
+}
+interface FlareAuthUser {
+    uid: string;
+    email: string;
+    email_verified: string;
+    [x: string]: any;
+}
+interface FlareAuthHydrationInput {
+    uid?: string | null;
+    id?: string | null;
+    accessToken?: string | null;
+    refreshToken?: string | null;
+    ticket?: string | null;
+    provider?: string;
+    email?: string | null;
+    emailVerified?: boolean;
+    email_verified?: boolean;
+    profile?: Partial<FlareAuthUser> | null;
+}
+interface FlareAuthHydrationOptions {
+    source?: string;
+    markBootstrapAttempted?: boolean;
+    syncSocket?: boolean;
+}
+interface RegisterPushTokenInput {
+    token: string;
+    platform?: string;
+    deviceId?: string;
+    topics?: string[];
+    authAppId?: string;
+}
+interface BrowserPushTokenOptions {
+    /** Service worker registration used for PushManager subscription. */
+    serviceWorkerRegistration?: ServiceWorkerRegistration;
+    /** Existing PushSubscription to reuse instead of subscribing again. */
+    subscription?: PushSubscription;
+    /** Public VAPID key used when creating a new PushSubscription. */
+    applicationServerKey?: string;
+    /** When true, unsubscribe old subscriptions before creating a new one. */
+    forceResubscribe?: boolean;
+}
+interface BrowserPushRegistrationOptions extends BrowserPushTokenOptions {
+    /** Optional explicit platform label. Defaults to "web". */
+    platform?: string;
+    deviceId?: string;
+    topics?: string[];
+    authAppId?: string;
+}
+interface SendPushNotificationInput {
+    title?: string;
+    body?: string;
+    image?: string;
+    data?: Record<string, unknown>;
+    tokens?: string[];
+    uid?: string;
+    topic?: string;
+    priority?: "normal" | "high";
+    ttlSeconds?: number;
+    dryRun?: boolean;
+    authAppId?: string;
+}
+interface PushSendResult {
+    sent: boolean;
+    appId: string;
+    targetCount: number;
+    successCount: number;
+    failureCount: number;
+    invalidatedTokenCount: number;
+    dryRun: boolean;
+}
+interface SendEmailInput {
+    to: string | string[];
+    tag: string;
+    values?: Record<string, unknown>;
+    authAppId?: string;
+}
+interface EmailSendResult {
+    sent: boolean;
+    appId: string;
+    tag: string;
+    recipientCount: number;
+    acceptedCount: number;
+    rejectedCount: number;
+    includeVerificationLink?: boolean;
+    linkId?: string;
+    verifyUrl?: string;
+    messageId?: string;
+}
+interface VerifyEmailLinkInput {
+    token: string;
+    tag?: string;
+    email?: string;
+    authAppId?: string;
+}
+interface EmailLinkVerifyResult {
+    verified: boolean;
+    alreadyVerified: boolean;
+    appId: string;
+    linkId: string;
+    email: string;
+    tag: string;
+    verifiedAt?: string;
+    acceptedByUid?: string;
+}
+type AuthStateListener = (session: FlareAuthSession & FlareAuthUser | null) => void;
+type AuthConfigListener = (conf: FlareAuthConfig) => void;
+interface SubscribeOptions {
+    skipSnapshot?: boolean;
+}
+type QueryOperator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "not-in" | "array-contains" | "array-contains-any" | "elem-match" | "like" | "not-like" | "contains" | "exists" | "not-exists";
+interface QueryConfig {
+    field: string;
+    op: QueryOperator;
+    value: unknown;
+}
+/** OR group */
+interface OrFilter {
+    or: AnyFilter[];
+}
+/** AND group */
+interface AndFilter {
+    and: AnyFilter[];
+}
+type AnyFilter = QueryConfig | OrFilter | AndFilter;
+type WhereCondition = Record<string, string | number | boolean | any[]>;
+interface OrderByClause {
+    field: string;
+    dir?: "asc" | "desc";
+}
+interface GroupByClause {
+    fields: string[];
+}
+interface HavingClause {
+    field: string;
+    op: "==" | "!=" | "<" | "<=" | ">" | ">=";
+    value: number;
+}
+interface CursorValue {
+    values: unknown[];
+}
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max" | "distinct";
+interface AggregateSpec {
+    fn: AggregateFunction;
+    field?: string;
+    alias?: string;
+}
+/**
+ * Join definition used by CollectionReference.Join().
+ *
+ * Example:
+ *   Join("tasks", { source: "id", target: "boardId", as: "tasks" })
+ */
+interface JoinQueryPattern {
+    where?: AnyFilter[];
+    orderBy?: OrderByClause[];
+    limit?: number;
+    offset?: number;
+    startAt?: CursorValue;
+    startAfter?: CursorValue;
+    endAt?: CursorValue;
+    endBefore?: CursorValue;
+    aggregate?: AggregateSpec[];
+    groupBy?: GroupByClause;
+    having?: HavingClause[];
+    vectorSearch?: VectorSearchClause;
+    select?: string[];
+    distinctField?: string;
+}
+interface NestedJoinClause extends JoinQueryPattern {
+    /** Joined collection name for this nested join. */
+    collection: string;
+    /** Field from the parent join result. */
+    source: string;
+    /** Field from this nested collection to match source. */
+    target: string;
+    /** Alias where nested rows are attached in each parent join row. */
+    as: string;
+    /** If true, expect at most one joined row. */
+    single?: boolean;
+    /** Recursive nested joins. */
+    joins?: NestedJoinClause[];
+}
+interface JoinClause extends JoinQueryPattern {
+    /** Field from the base collection (the collection you started the query on). */
+    source: string;
+    /** Field from the joined collection that should match source. */
+    target: string;
+    /** Alias where joined rows will be attached in each result object. */
+    as: string;
+    /** If true, expect at most one joined row (object instead of array on server side). */
+    single?: boolean;
+    /** Optional nested joins under this join. */
+    joins?: NestedJoinClause[];
+}
+/** Internal wire-ready join shape sent to server query engine. */
+interface StructuredJoinClause extends JoinQueryPattern {
+    from: string;
+    localField: string;
+    foreignField: string;
+    as: string;
+    single?: boolean;
+    joins?: StructuredJoinClause[];
+}
+interface VectorSearchClause {
+    field: string;
+    vector: number[];
+    k: number;
+    metric?: "cosine" | "euclidean" | "dotProduct";
+    minScore?: number;
+}
+/** Full structured query (document query + SQL-style feature set) */
+interface StructuredQuery {
+    where?: AnyFilter[];
+    orderBy?: OrderByClause[];
+    limit?: number;
+    offset?: number;
+    startAt?: CursorValue;
+    startAfter?: CursorValue;
+    endAt?: CursorValue;
+    endBefore?: CursorValue;
+    aggregate?: AggregateSpec[];
+    groupBy?: GroupByClause;
+    having?: HavingClause[];
+    joins?: StructuredJoinClause[];
+    vectorSearch?: VectorSearchClause;
+    select?: string[];
+    distinctField?: string;
+}
+type QueryPresetSpec<Params extends Record<string, unknown> = Record<string, unknown>, Row = any> = {
+    params: Params;
+    row: Row;
+};
+type QueryPresetMap = Record<string, QueryPresetSpec<any, any>>;
+type QueryPresetParams<TSpec> = TSpec extends QueryPresetSpec<infer Params, any> ? Params : Record<string, unknown>;
+type QueryPresetRow<TSpec> = TSpec extends QueryPresetSpec<any, infer Row> ? Row : any;
+type ChangeOperation = 'insert' | 'update' | 'replace' | 'delete';
+/**
+ * Fired once when the subscription is first established.
+ * `data` is always an array — the full matching collection snapshot.
+ */
+interface SnapshotEvent<T = any> {
+    type: 'snapshot';
+    subscriptionId: string;
+    collection: string;
+    data: T[];
+}
+/**
+ * Fired on every subsequent document mutation that matches the subscription query.
+ * `data` is the single affected document (null on delete).
+ */
+interface ChangeEvent<T = any> {
+    type: 'change';
+    subscriptionId: string;
+    collection: string;
+    docId: string;
+    operation: ChangeOperation;
+    data: T | null;
+}
+/** Discriminated union — narrow on `event.type` to get the right shape. */
+type SubscriptionData<T = any> = SnapshotEvent<T> | ChangeEvent<T>;
+type SubscriptionCallback<T = any> = (data: SubscriptionData<T>) => void;
+interface SubscriptionError {
+    code?: string;
+    message: string;
+    permissionDenied: boolean;
+    raw?: unknown;
+}
+type SubscriptionErrorCallback = (error: SubscriptionError) => void;
+interface SubscriptionHandle {
+    (): void;
+    unsubscribe: () => void;
+    onError: (callback: SubscriptionErrorCallback) => SubscriptionHandle;
+    onPermissionDenied: (callback: SubscriptionErrorCallback) => SubscriptionHandle;
+    catch: (callback: SubscriptionErrorCallback) => SubscriptionHandle;
+}
+type DocAddedCallback<T = any> = (data: T, docId: string) => void;
+type DocUpdatedCallback<T = any> = (data: T, docId: string) => void;
+type DocDeletedCallback<T = any> = (docId: string) => void;
+type DocChangedCallback<T = any> = (data: T | null, docId: string, operation: ChangeOperation) => void;
+type StreamFlushReason = 'snapshot' | 'change-batch';
+interface CollectionStreamOptions<T = any> {
+    /** Delay before a queued burst is flushed to listeners. */
+    flushMs?: number;
+    /** Flush immediately when queued changes reach this count. */
+    maxBatchSize?: number;
+    /** Field used to identify docs inside snapshots when getId is not provided. */
+    idField?: keyof T & string;
+    /** Custom identifier extractor for snapshot rows. */
+    getId?: (doc: T) => string | undefined;
+    /** Where newly inserted docs should be placed when they were not in snapshot. */
+    insertAt?: 'start' | 'end';
+    /** Optional cap to keep only the newest N docs in local stream state. */
+    maxDocs?: number;
+    /** Optional local sort run after flush. */
+    sort?: (a: T, b: T) => number;
+}
+interface CollectionStreamMeta {
+    reason: StreamFlushReason;
+    batchSize: number;
+    version: number;
+    ready: boolean;
+}
+type CollectionStreamListener<T = any> = (rows: readonly T[], meta: CollectionStreamMeta) => void;
+interface CollectionStream<T = any> {
+    /** Subscribe to stream updates (call unsubscribe to stop). */
+    subscribe: (listener: CollectionStreamListener<T>, emitCurrent?: boolean) => () => void;
+    /** Returns the latest immutable snapshot of rows. */
+    getSnapshot: () => readonly T[];
+    /** Returns true after the initial snapshot has been received. */
+    isReady: () => boolean;
+    /** Monotonic version incremented on each flush. */
+    getVersion: () => number;
+    /** Stop the underlying realtime subscription and cleanup timers/listeners. */
+    close: () => void;
+    /** Attach subscription-level error handler. */
+    onError: (callback: SubscriptionErrorCallback) => CollectionStream<T>;
+    /** Attach permission-denied handler. */
+    onPermissionDenied: (callback: SubscriptionErrorCallback) => CollectionStream<T>;
+}
+interface CollectionExternalStore<T = any> {
+    /** Standard external-store subscribe signature used by UI store hooks. */
+    subscribe: (onStoreChange: () => void) => () => void;
+    /** Returns current immutable rows snapshot. */
+    getSnapshot: () => readonly T[];
+    /** Server snapshot fallback for SSR-safe store hooks. */
+    getServerSnapshot: () => readonly T[];
+    /** Access to underlying realtime stream for advanced handlers. */
+    stream: CollectionStream<T>;
+    /** Stops realtime stream and detaches listeners. */
+    destroy: () => void;
+}
+interface DocumentSnapshot<T = any> {
+    id: string;
+    data: T | null;
+    exists: boolean;
+}
+interface QuerySnapshot<T = any> {
+    docs: DocumentSnapshot<T>[];
+    size: number;
+    empty: boolean;
+}
+interface OfflineOperation {
+    id: string;
+    type: 'write' | 'delete';
+    collection: string;
+    docId: string;
+    data?: Record<string, unknown>;
+    merge?: boolean;
+    clientTs: number;
+}
+interface AuthResult {
+    uid: string;
+    token?: string;
+}
+type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting' | 'error';
+interface AuthWithPendingVerificationResult {
+    verificationRequired: true;
+    created: true;
+    emailSent: boolean;
+    preview?: {
+        code: string;
+        link: string;
+    };
+}
+interface AuthWithTokenResult extends AuthResult {
+    accessToken: string;
+    refreshToken: string | null;
+    authToken: AuthToken;
+    created: boolean;
+}
+interface PresenceMember {
+    uid: string;
+    socketId: string;
+    room: string;
+    meta?: Record<string, unknown>;
+    joinedAt: number;
+    lastSeen: number;
+}
+type PresenceCallback = (members: PresenceMember[]) => void;
+type PresenceJoinCallback = (member: PresenceMember) => void;
+type PresenceLeaveCallback = (uid: string) => void;
+/** Fields marked as vector will be auto-embedded before write */
+type VectorFieldConfig = {
+    /** Dimensions of the vector (e.g. 1536 for OpenAI ada-002) */
+    dimensions: number;
+    /** Optional custom embedding function; defaults to client-configured embedder */
+    embed?: (text: string) => Promise<number[]>;
+};
+type RulePermission = "create" | "read" | "update" | "delete";
+interface FlareRule {
+    id: string;
+    name: string;
+    auth: "any" | "guest" | "auth";
+    collection: string;
+    document?: string;
+    condition?: string;
+    permissions: RulePermission[];
+}
+interface SecurityRuleEntry {
+    ".read"?: string;
+    ".write"?: string;
+    ".create"?: string;
+    ".update"?: string;
+    ".delete"?: string;
+}
+type SecurityRulesMap = Record<string, SecurityRuleEntry>;
+declare const flareRulesToSecurityMap: (rules: FlareRule[]) => SecurityRulesMap;
+declare const securityMapToFlareRules: (rules: SecurityRulesMap) => FlareRule[];
+
+/**
+ * Parse ORM-style where condition: { age: ">= 25", role: "admin" }
+ * Returns array of QueryConfig objects
+ */
+declare function parseWhereCondition(condition: WhereCondition): QueryConfig[];
+/**
+ * Parse string value to appropriate type
+ */
+declare function parseValue(val: string): any;
+/**
+ * Query builder for document operations (ORM-style)
+ * Supports: doc('users').update({...}).where({ id: 'alice' })
+ *
+ * This class is thenable - you can await it directly without .execute() or .get()
+ * @example
+ * await doc('users').where({ id: 'alice' })
+ * await doc('users').update({ name: 'Alice' }).where({ id: 'alice' })
+ */
+declare class DocumentQueryBuilder<T = any> implements PromiseLike<T | null | void> {
+    private client;
+    private collection;
+    private docIdFromRef?;
+    private whereCondition?;
+    private updateData?;
+    private setData?;
+    private deleteOp;
+    private promise?;
+    constructor(client: FlareClient<any>, collection: string, docIdFromRef?: string | undefined);
+    /**
+     * Set where condition
+     */
+    where(condition: WhereCondition): this;
+    /**
+     * Set update data (for update operations)
+     */
+    update(data: Partial<T>): this;
+    /**
+     * Set data (for set operations)
+     */
+    set(data: Partial<T>): this;
+    /**
+     * Mark for deletion
+     */
+    delete(): this;
+    /**
+     * Get the document ID from doc() reference or where condition.
+     */
+    private getDocId;
+    /**
+     * Execute the query
+     * @deprecated Use await directly instead of .execute()
+     */
+    execute(): Promise<T | null | void>;
+    /**
+     * Internal execute method
+     */
+    private _execute;
+    /**
+     * Make this class thenable so it can be awaited directly
+     */
+    then<TResult1 = T | null | void, TResult2 = never>(onfulfilled?: ((value: T | null | void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    /**
+     * Get the document data once
+     */
+    get(): Promise<T | null>;
+    /**
+     * Subscribe to real-time updates
+     */
+    onSnapshot(callback: SubscriptionCallback<T>): () => void;
+}
+
+/** Document reference */
+declare class DocumentReference<T = any> {
+    private client;
+    readonly collection: string;
+    readonly id: string;
+    constructor(client: FlareClient<any>, collection: string, id: string);
+    get(): Promise<T | null>;
+    set(data: Partial<T>): Promise<void>;
+    update(data: Partial<T>): Promise<void>;
+    delete(): Promise<void>;
+    onSnapshot(callback: SubscriptionCallback<T>): () => void;
+    /**
+     * Fires when this document is updated / replaced.
+     */
+    onDocUpdated(callback: DocUpdatedCallback<T>): () => void;
+    /**
+     * Fires when this document is deleted.
+     */
+    onDocDeleted(callback: DocDeletedCallback<T>): () => void;
+    /**
+     * Fires on any change to this document (update / delete).
+     * `data` is null on deletes.
+     */
+    onDocChanged(callback: DocChangedCallback<T>): () => void;
+}
+
+type CollectionPresetMethods<TPresetMap extends QueryPresetMap> = {
+    [K in keyof TPresetMap & string]: (params: QueryPresetParams<TPresetMap[K]>) => CollectionQuery<QueryPresetRow<TPresetMap[K]>, TPresetMap>;
+};
+type CollectionQuery<T = any, TPresetMap extends QueryPresetMap = {}> = CollectionReference<T, TPresetMap> & CollectionPresetMethods<TPresetMap>;
+declare class CollectionReference<T = any, TPresetMap extends QueryPresetMap = {}> implements PromiseLike<T[]> {
+    private client;
+    readonly collection: string;
+    private sq;
+    private promise?;
+    constructor(client: FlareClient<TPresetMap>, collection: string);
+    doc(id: string): DocumentReference<T>;
+    private clone;
+    private normalizeFilterValue;
+    private normalizeFilter;
+    private toQueryFilters;
+    private appendOperatorFilter;
+    private appendAndFilters;
+    private toOrNode;
+    private toAndNode;
+    private isLeafFilter;
+    private isIdentityGuard;
+    private splitIdentityGuards;
+    private appendOrFilters;
+    private appendFilters;
+    with<Name extends keyof TPresetMap & string>(name: Name, params: QueryPresetParams<TPresetMap[Name]>): CollectionQuery<QueryPresetRow<TPresetMap[Name]>, TPresetMap>;
+    with(name: string, params?: Record<string, unknown>): CollectionQuery<T, TPresetMap>;
+    /** ORM shorthand: .where({ age: ">= 25", role: "admin" }) */
+    where(condition: WhereCondition): CollectionQuery<T, TPresetMap>;
+    and(condition: WhereCondition): CollectionQuery<T, TPresetMap>;
+    or(condition: WhereCondition): CollectionQuery<T, TPresetMap>;
+    in(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    andIn(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    orIn(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    notIn(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    andNotIn(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    orNotIn(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    arrayContains(field: string, value: unknown): CollectionQuery<T, TPresetMap>;
+    andArrayContains(field: string, value: unknown): CollectionQuery<T, TPresetMap>;
+    orArrayContains(field: string, value: unknown): CollectionQuery<T, TPresetMap>;
+    arrayContainsAny(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    andArrayContainsAny(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    orArrayContainsAny(field: string, values: unknown[] | unknown): CollectionQuery<T, TPresetMap>;
+    some(field: string, condition: Record<string, unknown>): CollectionQuery<T, TPresetMap>;
+    andSome(field: string, condition: Record<string, unknown>): CollectionQuery<T, TPresetMap>;
+    orSome(field: string, condition: Record<string, unknown>): CollectionQuery<T, TPresetMap>;
+    like(field: string, value: string): CollectionQuery<T, TPresetMap>;
+    andLike(field: string, value: string): CollectionQuery<T, TPresetMap>;
+    orLike(field: string, value: string): CollectionQuery<T, TPresetMap>;
+    notLike(field: string, value: string): CollectionQuery<T, TPresetMap>;
+    andNotLike(field: string, value: string): CollectionQuery<T, TPresetMap>;
+    orNotLike(field: string, value: string): CollectionQuery<T, TPresetMap>;
+    exists(field: string): CollectionQuery<T, TPresetMap>;
+    andExists(field: string): CollectionQuery<T, TPresetMap>;
+    orExists(field: string): CollectionQuery<T, TPresetMap>;
+    notExists(field: string): CollectionQuery<T, TPresetMap>;
+    andNotExists(field: string): CollectionQuery<T, TPresetMap>;
+    orNotExists(field: string): CollectionQuery<T, TPresetMap>;
+    /** Get items starting from the most recently created (descending sequence) */
+    latest(): CollectionQuery<T, TPresetMap>;
+    /** Get items starting from the most recently created (descending sequence) */
+    newest(): CollectionQuery<T, TPresetMap>;
+    /** Get items starting from the first ever created (ascending sequence) */
+    oldest(): CollectionQuery<T, TPresetMap>;
+    orderBy(field: string, dir?: "asc" | "desc"): CollectionQuery<T, TPresetMap>;
+    limit(n: number): CollectionQuery<T, TPresetMap>;
+    offset(n: number): CollectionQuery<T, TPresetMap>;
+    startAt(...values: unknown[]): CollectionQuery<T, TPresetMap>;
+    startAfter(...values: unknown[]): CollectionQuery<T, TPresetMap>;
+    endAt(...values: unknown[]): CollectionQuery<T, TPresetMap>;
+    endBefore(...values: unknown[]): CollectionQuery<T, TPresetMap>;
+    aggregate(...specs: AggregateSpec[]): CollectionQuery<T, TPresetMap>;
+    count(alias?: string): CollectionQuery<T, TPresetMap>;
+    sum(field: string, alias?: string): CollectionQuery<T, TPresetMap>;
+    avg(field: string, alias?: string): CollectionQuery<T, TPresetMap>;
+    min(field: string, alias?: string): CollectionQuery<T, TPresetMap>;
+    max(field: string, alias?: string): CollectionQuery<T, TPresetMap>;
+    distinct(field: string, alias?: string): CollectionQuery<T, TPresetMap>;
+    groupBy(...fields: string[]): CollectionQuery<T, TPresetMap>;
+    having(field: string, op: HavingClause['op'], value: number): CollectionQuery<T, TPresetMap>;
+    private buildStructuredJoin;
+    private cloneStructuredJoin;
+    private appendNestedJoinByAlias;
+    private parseRelationRef;
+    /**
+     * Join another collection into this query.
+     *
+     * @param collectionName Joined collection name.
+     * @param j Join mapping clause.
+     * @example
+     *   flare.collection("boards")
+     *     .join("tasks", { source: "id", target: "boardId", as: "tasks" })
+     *     .get();
+     */
+    join(collectionName: string, j: JoinClause): CollectionQuery<T, TPresetMap>;
+    /**
+     * Append a nested join under an existing join alias.
+     * Example:
+     *   .join("lists", { source: "id", target: "boardId", as: "lists" })
+     *   .joinNested("lists", "cards", { source: "id", target: "listId", as: "cards" })
+     */
+    joinNested(parentAlias: string, collectionName: string, j: JoinClause): CollectionQuery<T, TPresetMap>;
+    Join(collectionName: string, j: JoinClause): CollectionQuery<T, TPresetMap>;
+    JoinNested(parentAlias: string, collectionName: string, j: JoinClause): CollectionQuery<T, TPresetMap>;
+    /**
+     * SQL-like relation shorthand.
+     * Example: .withRelation("team.uid->users.id", { as: "teamMembers" })
+     */
+    withRelation(relation: string, options?: (Omit<JoinClause, 'source' | 'target' | 'as'> & {
+        as?: string;
+    })): CollectionQuery<T, TPresetMap>;
+    select(...fields: string[]): CollectionQuery<T, TPresetMap>;
+    /** Returns unique values for a single field */
+    distinctField(field: string): CollectionQuery<T, TPresetMap>;
+    /**
+     * KNN nearest-neighbour search (requires Atlas vector index).
+     * @example
+     *   col.vectorSearch({ field: "embedding", vector: [...1536 numbers...], k: 10 })
+     */
+    vectorSearch(opts: VectorSearchClause): CollectionQuery<T, TPresetMap>;
+    getRawQuery(): {
+        collection: string;
+        query: StructuredQuery;
+    };
+    get(): Promise<T[]>;
+    first(): Promise<T | null>;
+    last(): Promise<T | null>;
+    private _isStructured;
+    private _execute;
+    private _executeQuery;
+    private _executeSubscribe;
+    then<TResult1 = T[], TResult2 = never>(onfulfilled?: ((value: T[]) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    /**
+     * Subscribe to real-time updates.
+     * The full StructuredQuery (including orderBy, where, limit, offset) is sent
+     * to the server so the initial snapshot respects all constraints.
+     * Individual change events are then sorted / filtered client-side to keep
+     * the live result consistent.
+     */
+    onSnapshot(callback: SubscriptionCallback<T[]>): SubscriptionHandle;
+    /**
+     * High-throughput stream wrapper for bursty collections (chat, feeds, logs).
+     * It keeps local state and flushes change bursts in batches to reduce UI churn.
+     */
+    stream(options?: CollectionStreamOptions<T>): CollectionStream<T>;
+    /**
+     * Framework-agnostic external-store bridge.
+     * Compatible with UI hooks expecting subscribe/getSnapshot signatures.
+     */
+    asStore(options?: CollectionStreamOptions<T>): CollectionExternalStore<T>;
+    onDocAdded(callback: DocAddedCallback<T>): () => void;
+    onDocUpdated(callback: DocUpdatedCallback<T>): () => void;
+    onDocDeleted(callback: DocDeletedCallback<T>): () => void;
+    onDocChanged(callback: DocChangedCallback<T>): () => void;
+    add(data: Partial<T>): Promise<DocumentReference<T>>;
+    update(data: Partial<T>): DocumentQueryBuilder<T>;
+    delete(): DocumentQueryBuilder<T>;
+}
+
+/** Client Request */
+declare enum FlareAction {
+    SUBSCRIBE = "subscribe",
+    UNSUBSCRIBE = "unsubscribe",
+    WRITE = "write",
+    DELETE = "delete",
+    AUTH = "auth",
+    PING = "ping",
+    OFFLINE_SYNC = "offline_sync",
+    CALL = "call",
+    /** One-shot rich query (no real-time subscription) */
+    QUERY = "query",
+    /** Presence */
+    PRESENCE_JOIN = "presence_join",
+    PRESENCE_LEAVE = "presence_leave",
+    PRESENCE_HEARTBEAT = "presence_heartbeat"
+}
+/** Server Response */
+declare enum FlareEvent {
+    SNAPSHOT = "snapshot",
+    CHANGE = "change",
+    ERROR = "error",
+    ACK = "ack",
+    PONG = "pong",
+    AUTH_OK = "auth_ok",
+    OFFLINE_ACK = "offline_ack",
+    CALL_RESPONSE = "call_response",
+    QUERY_RESULT = "query_result",
+    PRESENCE_STATE = "presence_state",
+    PRESENCE_JOIN = "presence_join",
+    PRESENCE_LEAVE = "presence_leave"
+}
+interface BaseMessage {
+    id: string;
+    type: FlareAction | FlareEvent;
+    ts: number;
+}
+interface SubscribeMessage extends BaseMessage {
+    type: FlareAction.SUBSCRIBE;
+    collection: string;
+    docId?: string;
+    query?: Record<string, unknown>;
+    skipSnapshot?: boolean;
+    resumeToken?: string;
+}
+
+type TransportOptions = {
+    url: string;
+    onMessage: (data: any) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onError?: (error: Error) => void;
+    autoReconnect?: boolean;
+    reconnectDelay?: number;
+    maxReconnectDelay?: number;
+    debug?: boolean;
+    /** RSA public key (PEM). When set, all outgoing messages are RSA-OAEP encrypted. */
+    publicKey?: string;
+};
+
+declare class FlareTransport {
+    private socket;
+    private reconnectInterval;
+    private maxReconnectDelay;
+    private isConnected;
+    private shouldReconnect;
+    private options;
+    private messageQueue;
+    private heartbeatInterval;
+    private connectionTimeout;
+    constructor(options: TransportOptions);
+    connect(): void;
+    private handleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private flushQueue;
+    send(message: object): void;
+    disconnect(): void;
+    get connected(): boolean;
+    private log;
+}
+
+type ConnectionListener = (state: ConnectionState) => void;
+type ErrorListener = (error: Error) => void;
+type HttpResponseSnapshot = {
+    status: number;
+    headers: Record<string, string>;
+    data: any;
+};
+type ActiveSubscription = {
+    baseId: string;
+    liveId: string;
+    collection: string;
+    docId?: string;
+    query?: StructuredQuery;
+    callback: SubscriptionCallback;
+    options: SubscribeOptions;
+};
+type QueryPresetHandler<Params extends Record<string, unknown> = Record<string, unknown>, Row = any> = (ref: CollectionQuery<any, any>, params: Params) => CollectionQuery<Row, any>;
+/** Embedder function registered by the user */
+type EmbedFn = (text: string) => Promise<number[]>;
+declare class FlareBase<TPresetMap extends QueryPresetMap = {}> {
+    protected transport: FlareTransport;
+    protected readonly config: FlareConfig;
+    protected readonly pendingAcks: Map<string, (value: any) => void>;
+    protected readonly subscriptions: Map<string, SubscriptionCallback>;
+    protected readonly activeSubscriptions: Map<string, ActiveSubscription>;
+    protected readonly queryPresets: Map<string, QueryPresetHandler<any, any>>;
+    protected readonly subscriptionErrorHandlers: Map<string, Set<SubscriptionErrorCallback>>;
+    protected readonly subscriptionPermissionHandlers: Map<string, Set<SubscriptionErrorCallback>>;
+    protected readonly subscriptionLastErrors: Map<string, SubscriptionError>;
+    protected readonly offlineQueue: any[];
+    protected currentState: ConnectionState;
+    protected connectionListeners: ConnectionListener[];
+    protected errorListeners: ErrorListener[];
+    protected isDebug: boolean;
+    protected socketAuthUid: string;
+    protected pendingSubscriptionReplay: boolean;
+    protected subscriptionReplayPromise: Promise<void>;
+    protected requestTraceSeq: number;
+    protected requestTimingEnabled: boolean;
+    protected httpInFlight: Map<string, Promise<HttpResponseSnapshot>>;
+    protected httpResponseCache: Map<string, HttpResponseSnapshot>;
+    protected readonly maxHttpCacheEntries = 200;
+    protected presenceCallbacks: Map<string, PresenceCallback[]>;
+    protected presenceJoinCbs: Map<string, PresenceJoinCallback[]>;
+    protected presenceLeaveCbs: Map<string, PresenceLeaveCallback[]>;
+    protected presenceHeartbeatTimer?: ReturnType<typeof setInterval>;
+    protected embedder?: EmbedFn;
+    protected vectorSchema: Map<string, Map<string, VectorFieldConfig>>;
+    protected throwFetchFlareError(payload: unknown, fallbackMessage: string, fallbackCode: string): never;
+    protected nowMs(): number;
+    protected normalizeHeaders(headers?: HeadersInit): Record<string, string>;
+    protected redactHeaders(headers: Record<string, string>): Record<string, string>;
+    protected stableStringify(value: unknown): string;
+    protected buildHttpCacheKey(method: string, url: string, headers: Record<string, string>, body: unknown, credentials?: RequestCredentials): string;
+    protected shouldCacheResponse(method: string, url: string): boolean;
+    protected rememberHttpResponse(key: string, value: HttpResponseSnapshot): void;
+    protected createTimedFetchTrace(snapshot: HttpResponseSnapshot, requestId: number, startedAtMs: number, method: string, url: string, networkMs: number): {
+        response: {
+            status: number;
+            ok: boolean;
+            headers: {
+                get: (name: string) => string | null;
+            };
+            json: () => Promise<any>;
+        };
+        requestId: number;
+        startedAtMs: number;
+        networkMs: number;
+        method: string;
+        url: string;
+    };
+    protected logHttpTiming(...args: any[]): void;
+    protected mergeHeaders(base: HeadersInit | undefined, extra: Record<string, string>): HeadersInit;
+    protected toWireField(field: string): string;
+    protected fromWireField(field: string): string;
+    protected normalizeOutboundData(value: unknown): unknown;
+    protected normalizeInboundData(value: unknown): unknown;
+    private getDataMapper;
+    private runMapper;
+    private applyJoinAliasMappers;
+    mapInboundResult(collection: string, payload: unknown, query?: StructuredQuery): unknown;
+    protected normalizeOutboundAnyFilter(filter: Record<string, unknown>): Record<string, unknown>;
+    protected normalizeOutboundQuery(query: unknown): unknown;
+    protected timedFetch(label: string, input: string, init?: RequestInit): Promise<{
+        response: {
+            status: number;
+            ok: boolean;
+            headers: {
+                get: (name: string) => string | null;
+            };
+            json: () => Promise<any>;
+        };
+        requestId: number;
+        startedAtMs: number;
+        networkMs: number;
+        method: string;
+        url: string;
+    }>;
+    protected parseJsonWithTiming(label: string, trace: {
+        requestId: number;
+        startedAtMs: number;
+        response: {
+            status: number;
+            ok: boolean;
+            headers: {
+                get: (name: string) => string | null;
+            };
+            json: () => Promise<any>;
+        };
+        networkMs: number;
+        method: string;
+        url: string;
+    }): Promise<any>;
+    protected getHttpBase(): string;
+    protected log(...args: any[]): void;
+    constructor(config: FlareConfig);
+    connect(): void;
+    disconnect(): void;
+    get connectionState(): ConnectionState;
+    get isConnected(): boolean;
+    onConnectionStateChange(listener: ConnectionListener): () => void;
+    onError(callback: ErrorListener): () => void;
+    collection<T = any>(name: string): CollectionQuery<T, TPresetMap>;
+    registerQueryPreset<Name extends string, Params extends Record<string, unknown>, Row = any>(name: Name, handler: QueryPresetHandler<Params, Row>): this & FlareBase<TPresetMap & Record<Name, QueryPresetSpec<Params, Row>>>;
+    registerQueryPresets<TRegistry extends Record<string, QueryPresetHandler<any, any>>>(presets: TRegistry): this & FlareBase<TPresetMap & {
+        [K in keyof TRegistry]: TRegistry[K] extends QueryPresetHandler<infer Params, infer Row> ? QueryPresetSpec<Params, Row> : QueryPresetSpec<Record<string, unknown>, any>;
+    }>;
+    hasQueryPreset(name: string): boolean;
+    applyQueryPreset<Name extends keyof TPresetMap & string>(ref: CollectionReference<any, TPresetMap>, name: Name, params: QueryPresetParams<TPresetMap[Name]>): CollectionQuery<QueryPresetRow<TPresetMap[Name]>, TPresetMap>;
+    applyQueryPreset<T = any>(ref: CollectionQuery<T, TPresetMap>, name: string, params?: Record<string, unknown>): CollectionQuery<T, TPresetMap>;
+    doc<T = any>(collection: string): DocumentQueryBuilder<T>;
+    doc<T = any>(collection: string, id: string): DocumentReference<T>;
+    ping(): Promise<number>;
+    call<T = Record<string, unknown>>(topic: string, payload?: Record<string, unknown>): Promise<T>;
+    query<T = Record<string, unknown>>(collection: string, q?: StructuredQuery): Promise<T[]>;
+    setEmbedder(fn: EmbedFn): void;
+    markVectorField(collection: string, field: string, config?: VectorFieldConfig): void;
+    embedVectorFields(collection: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    joinPresence(room: string, meta?: Record<string, unknown>): Promise<() => void>;
+    leavePresence(room: string): Promise<void>;
+    onPresenceState(room: string, cb: PresenceCallback): () => void;
+    onPresenceJoin(room: string, cb: PresenceJoinCallback): () => void;
+    onPresenceLeave(room: string, cb: PresenceLeaveCallback): () => void;
+    private _startPresenceHeartbeat;
+    private _stopPresenceHeartbeat;
+    syncOffline(): Promise<void>;
+    protected beforeActivateSubscription(_entry: ActiveSubscription): Promise<void>;
+    protected activateSubscription(entry: ActiveSubscription): Promise<void>;
+    protected toSubscriptionError(err: unknown): SubscriptionError;
+    protected emitSubscriptionError(baseId: string, error: SubscriptionError): void;
+    protected replayActiveSubscriptions(): Promise<void>;
+    subscribe(subId: string, collection: string, docId: string | undefined, query: StructuredQuery | undefined, callback: SubscriptionCallback, options?: SubscribeOptions): SubscriptionHandle;
+    send(type: FlareAction, payload: any): Promise<any>;
+    private handleTransportError;
+    protected onConnected(): void;
+    protected onDisconnected(): void;
+    protected setState(state: ConnectionState): void;
+    protected handleIncoming(msg: any): void;
+}
+
+declare class FlareAuth<TPresetMap extends QueryPresetMap = {}> extends FlareBase<TPresetMap> {
+    static AUTH_TRACE_STORAGE_KEY: string;
+    protected pushServiceWorkerInitPromise?: Promise<ServiceWorkerRegistration | null>;
+    /** Current authentication configuration */
+    protected userId?: string;
+    protected authToken?: string;
+    protected authTicket?: string;
+    protected authConfig?: FlareAuthConfig;
+    protected authStateListeners: AuthStateListener[];
+    protected authConfigListeners: AuthConfigListener[];
+    protected authSession: FlareAuthSession | null;
+    protected currentProfile: FlareAuthUser | undefined;
+    protected authBootstrapAttempted: boolean;
+    protected authBootstrapPromise?: Promise<void>;
+    protected socketAuthSyncPromise?: Promise<void>;
+    /** In-memory CSRF token extracted from the `x-flare-csrf` response header */
+    protected csrfToken?: string;
+    protected csrfBootstrapAttempted: boolean;
+    protected csrfInitPromise?: Promise<void>;
+    protected isAuthTraceEnabled(): boolean;
+    protected traceAuth(event: string, details?: Record<string, unknown>): void;
+    setAuthTrace(enabled: boolean, persist?: boolean): void;
+    protected fetchAuthMe(token?: string): Promise<{
+        id?: string;
+        email?: string | null;
+        email_verified?: boolean;
+    }>;
+    isBootstrapAttempted(): boolean;
+    hydrateAuthState(input: FlareAuthHydrationInput | null, options?: FlareAuthHydrationOptions): Promise<void>;
+    loadAuthConfig(): Promise<FlareAuthConfig>;
+    onAuthConfigLoaded(listener: AuthConfigListener): () => void;
+    onAuthStateChanged(listener: AuthStateListener): () => void;
+    getCurrentUser(): FlareAuthUser | undefined;
+    getAuthTicket(): string | undefined;
+    consumeAuthTicket(): string | undefined;
+    private getDefaultCsrfCookieName;
+    /**
+     * Extract CSRF token from a server response.
+     * The server now sends it ONLY as the `x-flare-csrf` response header
+     * (not in the JSON body). We still support the body field as a fallback
+     * for older server versions.
+     */
+    protected extractCsrfToken(json: unknown, response?: {
+        headers: {
+            get: (name: string) => string | null;
+        };
+    }): string | undefined;
+    getCsrfHeaders(): Record<string, string>;
+    getCsrfCookieName(): string;
+    /**
+     * Read the CSRF token from a browser-readable cookie (set by the server as
+     * a non-HttpOnly fallback) or fall back to the in-memory value captured
+     * from the response header.
+     *
+     * Priority:
+     *   1. Non-HttpOnly cookie on the current domain (browser only)
+     *   2. In-memory value from `x-flare-csrf` response header
+     */
+    getCsrfToken(): string | null;
+    ensureCsrfProtection(): Promise<void>;
+    protected setAuthSession(session: FlareAuthSession | null, source?: string): void;
+    protected emitAuthState(): void;
+    protected setProfile(profile: FlareAuthUser): void;
+    protected ensureSessionForSocketAuth(reason: string): Promise<boolean>;
+    refreshAuthSession(refresh_token?: string): Promise<FlareAuthSession | null>;
+    protected updateSocketIdentity(uid?: string, forceReplay?: boolean): Promise<void>;
+    protected waitUntilConnected(): Promise<void>;
+    protected syncSocketAuth(accessToken?: string | null): Promise<void>;
+    protected beforeActivateSubscription(_entry: any): Promise<void>;
+    /**
+     * Fetch a fresh one-time WebSocket ticket from the server.
+     * Called on reconnect when neither an access token nor a cached ticket exists.
+     * Requires `config.ticketRefreshUrl` to be configured.
+     */
+    protected fetchFreshTicket(): Promise<string | null>;
+    protected onConnected(): void;
+    private toUint8ArrayFromBase64Url;
+    private encodePushTokenFromSubscription;
+    private fetchPushSetupConfig;
+    setupPushServiceWorker(): Promise<ServiceWorkerRegistration | null>;
+    requestPushPermission(): Promise<NotificationPermission>;
+    acquireBrowserPushToken(options?: BrowserPushTokenOptions): Promise<{
+        token: string;
+        subscription: PushSubscription;
+    }>;
+    enableBrowserPush(options?: BrowserPushRegistrationOptions): Promise<{
+        registered: boolean;
+        appId: string;
+        uid: string;
+        token: string;
+        platform?: string;
+        subscription: PushSubscription;
+    }>;
+    registerPushToken(input: RegisterPushTokenInput): Promise<{
+        registered: boolean;
+        appId: string;
+        uid: string;
+        token: string;
+        platform?: string;
+    }>;
+    unregisterPushToken(token: string, authAppId?: string): Promise<{
+        unregistered: boolean;
+        appId: string;
+        token: string;
+        removed: boolean;
+    }>;
+    sendPushNotification(input: SendPushNotificationInput): Promise<PushSendResult>;
+    auth(token: string): Promise<AuthResult>;
+    private getAuthRequestContentType;
+    private buildAuthRequestBody;
+    protected requestEmailPasswordToken(email: string, password: string, scope?: string[]): Promise<AuthToken & {
+        kind: string;
+    }>;
+    signInWithEmailAndPassword(email: string, password: string, options?: {
+        scope?: string[];
+        createIfMissing?: boolean;
+    }): Promise<AuthResult & {
+        kind?: string;
+        accessToken: string;
+        refreshToken: string | null;
+        authToken: AuthToken;
+        created?: boolean;
+    }>;
+    signInWithEmail(email: string, password: string, options?: {
+        scope?: string[];
+        createIfMissing?: boolean;
+    }): Promise<AuthResult & {
+        kind?: string;
+        accessToken: string;
+        refreshToken: string | null;
+        authToken: AuthToken;
+        created?: boolean;
+    }>;
+    createUserWithEmail(email: string, password: string, options?: {
+        scope?: string[];
+        additionalParams?: Record<string, string>;
+        signInIfAllowed?: boolean;
+    }): Promise<{
+        kind?: string;
+        verificationRequired: true;
+        verification_required: true;
+        emailSent: boolean;
+        email_sent: boolean;
+        message?: string;
+        preview?: {
+            code: string;
+            link: string;
+        };
+    } | (AuthResult & {
+        kind?: string;
+        accessToken: string;
+        access_token: string;
+        token_type: string;
+        expires_in: number;
+        refreshToken: string | null;
+        refresh_token: string | null;
+        scope: string;
+        expires_at: string | number;
+        sid: string;
+        authToken: AuthToken;
+        auth_token: AuthToken;
+        verificationRequired: false;
+        verification_required: false;
+        emailSent: boolean;
+        email_sent: boolean;
+        preview?: {
+            code: string;
+            link: string;
+        };
+    })>;
+    createUserWithEmailAndPassword(email: string, password: string, options?: {
+        scope?: string[];
+        additionalParams?: Record<string, string>;
+        signInIfAllowed?: boolean;
+    }): Promise<{
+        kind?: string;
+        verificationRequired: true;
+        verification_required: true;
+        emailSent: boolean;
+        email_sent: boolean;
+        message?: string;
+        preview?: {
+            code: string;
+            link: string;
+        };
+    } | (AuthResult & {
+        kind?: string;
+        accessToken: string;
+        access_token: string;
+        token_type: string;
+        expires_in: number;
+        refreshToken: string | null;
+        refresh_token: string | null;
+        scope: string;
+        expires_at: string | number;
+        sid: string;
+        authToken: AuthToken;
+        auth_token: AuthToken;
+        verificationRequired: false;
+        verification_required: false;
+        emailSent: boolean;
+        email_sent: boolean;
+        preview?: {
+            code: string;
+            link: string;
+        };
+    })>;
+    signInOrCreateWithEmail(email: string, password: string, options?: {
+        scope?: string[];
+        additionalParams?: Record<string, string>;
+    }): Promise<{
+        kind?: string;
+        verificationRequired: true;
+        created: true;
+        emailSent: boolean;
+        preview?: {
+            code: string;
+            link: string;
+        };
+    } | (AuthResult & {
+        accessToken: string;
+        refreshToken: string | null;
+        authToken: AuthToken;
+        created: boolean;
+    })>;
+    signInOrCreateWithEmailAndPassword(email: string, password: string, options?: {
+        scope?: string[];
+        additionalParams?: Record<string, string>;
+    }): Promise<{
+        kind?: string;
+        verificationRequired: true;
+        created: true;
+        emailSent: boolean;
+        preview?: {
+            code: string;
+            link: string;
+        };
+    } | (AuthResult & {
+        accessToken: string;
+        refreshToken: string | null;
+        authToken: AuthToken;
+        created: boolean;
+    })>;
+    sendEmailVerification(email: string): Promise<{
+        sent: boolean;
+        emailSent: boolean;
+        preview?: {
+            code: string;
+            link: string;
+        };
+    }>;
+    verifyEmailWithCode(email: string, code: string): Promise<{
+        verified: boolean;
+        email: string;
+    }>;
+    confirmEmailLink(token: string, email: string): Promise<{
+        verified: boolean;
+        email: string;
+    }>;
+    sendAccountRecovery(email: string): Promise<{
+        kind?: string;
+        sent: boolean;
+        emailSent?: boolean;
+        preview?: {
+            code: string;
+            token: string;
+        };
+    }>;
+    recoverAccountWithCode(email: string, code: string, newPassword: string): Promise<{
+        recovered: boolean;
+        email: string;
+        sessionsRevoked?: number;
+    }>;
+    recoverAccountWithToken(token: string, newPassword: string): Promise<{
+        recovered: boolean;
+        email: string;
+        sessionsRevoked?: number;
+    }>;
+    signOut(): Promise<void>;
+    protected registerWithEmail(email: string, password: string, options?: {
+        scope?: string[];
+        additionalParams?: Record<string, string>;
+        signInIfAllowed?: boolean;
+    }): Promise<Record<string, any>>;
+}
+
+/**
+ * Client/index.ts ─ entry point
+ *
+ * FlareClient is the public-facing class. All logic lives in:
+ *   - Client/base.ts  → transport, subscriptions, presence, vector, offline
+ *   - Client/auth.ts  → CSRF capture, all auth & session methods
+ *
+ * CSRF Protection (SSR-Only by Default)
+ * ────────────────────────────────────
+ * FlareClient does NOT automatically fetch CSRF on construction. Instead:
+ *
+ *   1. SSR (Next.js): Middleware fetches /auth/config once, sets CSRF as HttpOnly
+ *      cookie on response. Methods automatically use this cookie (no extra calls).
+ *
+ *   2. Browser-only (SPA): Explicitly call client.ensureCsrfProtection() before
+ *      mutations to fetch /auth/config and cache CSRF token in memory.
+ *
+ * Why? Eliminates redundant /auth/config calls in SSR, where every method used
+ * to fetch it again internally. Now CSRF bootstrapping happens once (in middleware),
+ * and auth methods just use getCsrfHeaders() which returns the cached token
+ * (if available) or empty object (relying on HttpOnly cookie validation).
+ *
+ * This file wires FlareAuth together and leaves CSRF bootstrapping to the user.
+ */
+
+declare class FlareClient<TPresetMap extends QueryPresetMap = {}> extends FlareAuth<TPresetMap> {
+    private autoPushRegisteredIdentity?;
+    constructor(config: FlareConfig);
+    private enableAutoPushNotificationsAfterAuth;
+    autoEnablePushNotifications(): Promise<void>;
+}
+
+export { type OrFilter as $, type AggregateFunction as A, type BaseMessage as B, type ChangeEvent as C, type DataMapperFn as D, type DocUpdatedCallback as E, type FlareConfig as F, DocumentQueryBuilder as G, DocumentReference as H, type DocumentSnapshot as I, type EmailLinkVerifyResult as J, type EmailSendResult as K, FlareAction as L, type FlareAuthConfig as M, type FlareAuthHydrationInput as N, type FlareAuthHydrationOptions as O, type FlareAuthProviderId as P, type FlareAuthProviderPublicConfig as Q, type FlareAuthSession as R, type FlareAuthUser as S, FlareEvent as T, type FlareRule as U, type GroupByClause as V, type HavingClause as W, type JoinClause as X, type JoinQueryPattern as Y, type NestedJoinClause as Z, type OfflineOperation as _, FlareClient as a, type OrderByClause as a0, type PresenceCallback as a1, type PresenceJoinCallback as a2, type PresenceLeaveCallback as a3, type PresenceMember as a4, type PushSendResult as a5, type QueryConfig as a6, type QueryOperator as a7, type QueryPresetMap as a8, type QueryPresetParams as a9, parseWhereCondition as aA, securityMapToFlareRules as aB, type QueryPresetRow as aa, type QueryPresetSpec as ab, type QuerySnapshot as ac, type RegisterPushTokenInput as ad, type RulePermission as ae, type SecurityRuleEntry as af, type SecurityRulesMap as ag, type SendEmailInput as ah, type SendPushNotificationInput as ai, type SnapshotEvent as aj, type StreamFlushReason as ak, type StructuredJoinClause as al, type StructuredQuery as am, type SubscribeMessage as an, type SubscribeOptions as ao, type SubscriptionCallback as ap, type SubscriptionData as aq, type SubscriptionError as ar, type SubscriptionErrorCallback as as, type SubscriptionHandle as at, type VectorFieldConfig as au, type VectorSearchClause as av, type VerifyEmailLinkInput as aw, type WhereCondition as ax, flareRulesToSecurityMap as ay, parseValue as az, type AggregateSpec as b, type AndFilter as c, type AnyFilter as d, type AuthConfigListener as e, type AuthResult as f, type AuthStateListener as g, type AuthWithPendingVerificationResult as h, type AuthWithTokenResult as i, type BrowserPushRegistrationOptions as j, type BrowserPushTokenOptions as k, type ChangeOperation as l, type CollectionExternalStore as m, type CollectionPresetMethods as n, type CollectionQuery as o, CollectionReference as p, type CollectionStream as q, type CollectionStreamListener as r, type CollectionStreamMeta as s, type CollectionStreamOptions as t, type ConnectionState as u, type CursorValue as v, type DataMapperRegistry as w, type DocAddedCallback as x, type DocChangedCallback as y, type DocDeletedCallback as z };