@zuzjs/flare 0.2.2 → 0.2.5

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { Anonymous, Apple, AuthGuard, AuthToken, CreateUserWithEmailAndPasswordI
  * Client Configuration
  */
 interface FlareConfig {
+    /** Base URL for the Flare API. */
     endpoint: string;
     /**
      * Optional HTTP base URL for auth API calls.
@@ -14,15 +15,26 @@ interface FlareConfig {
      * Example: '/api/flare'  (relative, browser resolves against current origin)
      */
     httpBase?: string;
+    /** Unique identifier for the application. */
     appId: string;
+    /** API key for the application. */
     apiKey?: string;
+    /** 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;
 }
 type FlareAuthProviderId = "credentials" | "anonymous" | "google" | "facebook" | "github" | "dropbox" | "apple" | "twitter";
 interface FlareAuthProviderPublicConfig {
@@ -59,7 +71,93 @@ interface FlareAuthSession {
     email?: string | null;
     emailVerified?: boolean;
 }
-type AuthStateListener = (session: FlareAuthSession | null) => void;
+interface FlareAuthUser {
+    uid: string;
+    email: string;
+    email_verified: string;
+    [x: string]: any;
+}
+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;
@@ -97,12 +195,62 @@ interface AggregateSpec {
     field?: string;
     alias?: string;
 }
-interface JoinClause {
+/**
+ * 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;
@@ -111,7 +259,7 @@ interface VectorSearchClause {
     metric?: "cosine" | "euclidean" | "dotProduct";
     minScore?: number;
 }
-/** Full structured query (Firestore + SQL feature set) */
+/** Full structured query (document query + SQL-style feature set) */
 interface StructuredQuery {
     where?: AnyFilter[];
     orderBy?: OrderByClause[];
@@ -124,11 +272,18 @@ interface StructuredQuery {
     aggregate?: AggregateSpec[];
     groupBy?: GroupByClause;
     having?: HavingClause[];
-    joins?: JoinClause[];
+    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.
@@ -155,6 +310,20 @@ interface ChangeEvent<T = any> {
 /** 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;
@@ -216,6 +385,26 @@ type VectorFieldConfig = {
     /** 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" }
@@ -244,7 +433,7 @@ declare class DocumentQueryBuilder<T = any> implements PromiseLike<T | null | vo
     private setData?;
     private deleteOp;
     private promise?;
-    constructor(client: FlareClient, collection: string, legacyId?: string | undefined);
+    constructor(client: FlareClient<any>, collection: string, legacyId?: string | undefined);
     /**
      * Set where condition
      */
@@ -295,7 +484,7 @@ declare class DocumentReference<T = any> {
     private client;
     readonly collection: string;
     readonly id: string;
-    constructor(client: FlareClient, collection: string, 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>;
@@ -321,46 +510,76 @@ declare class DocumentReference<T = any> {
     onDocChanged(callback: DocChangedCallback<T>): () => void;
 }
 
-declare class CollectionReference<T = any> implements PromiseLike<T[]> {
+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, collection: string);
+    constructor(client: FlareClient<TPresetMap>, collection: string);
     doc(id: string): DocumentReference<T>;
     private clone;
+    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): CollectionReference<T>;
+    where(condition: WhereCondition): CollectionQuery<T, TPresetMap>;
     /** Explicit field/op/value */
-    where(field: string, op: QueryConfig['op'], value: unknown): CollectionReference<T>;
+    where(field: string, op: QueryConfig['op'], value: unknown): CollectionQuery<T, TPresetMap>;
     /** OR group: .orWhere([{ field:"status", op:"==", value:"active" }, ...]) */
-    orWhere(filters: QueryConfig[]): CollectionReference<T>;
-    orderBy(field: string, dir?: "asc" | "desc"): CollectionReference<T>;
-    limit(n: number): CollectionReference<T>;
-    offset(n: number): CollectionReference<T>;
-    startAt(...values: unknown[]): CollectionReference<T>;
-    startAfter(...values: unknown[]): CollectionReference<T>;
-    endAt(...values: unknown[]): CollectionReference<T>;
-    endBefore(...values: unknown[]): CollectionReference<T>;
-    aggregate(...specs: AggregateSpec[]): CollectionReference<T>;
-    count(alias?: string): CollectionReference<T>;
-    sum(field: string, alias?: string): CollectionReference<T>;
-    avg(field: string, alias?: string): CollectionReference<T>;
-    min(field: string, alias?: string): CollectionReference<T>;
-    max(field: string, alias?: string): CollectionReference<T>;
-    distinct(field: string, alias?: string): CollectionReference<T>;
-    groupBy(...fields: string[]): CollectionReference<T>;
-    having(field: string, op: HavingClause['op'], value: number): CollectionReference<T>;
-    join(j: JoinClause): CollectionReference<T>;
-    select(...fields: string[]): CollectionReference<T>;
+    orWhere(filters: QueryConfig[]): CollectionQuery<T, TPresetMap>;
+    /** Get items starting from the most recently created (descending sequence) */
+    latest(): 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;
+    /**
+     * 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>;
+    /**
+     * Legacy join signature.
+     * Prefer Join(collectionName, clause) for better readability.
+     */
+    join(collectionName: string, j: JoinClause): CollectionQuery<T, TPresetMap>;
+    join(j: JoinClause & {
+        from?: string;
+        collection?: string;
+    }): CollectionQuery<T, TPresetMap>;
+    select(...fields: string[]): CollectionQuery<T, TPresetMap>;
     /** Returns unique values for a single field */
-    distinctField(field: string): CollectionReference<T>;
+    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): CollectionReference<T>;
+    vectorSearch(opts: VectorSearchClause): CollectionQuery<T, TPresetMap>;
     get(): Promise<T[]>;
     private _isStructured;
     private _execute;
@@ -374,7 +593,7 @@ declare class CollectionReference<T = any> implements PromiseLike<T[]> {
      * Individual change events are then sorted / filtered client-side to keep
      * the live result consistent.
      */
-    onSnapshot(callback: SubscriptionCallback<T[]>): () => void;
+    onSnapshot(callback: SubscriptionCallback<T[]>): SubscriptionHandle;
     onDocAdded(callback: DocAddedCallback<T>): () => void;
     onDocUpdated(callback: DocUpdatedCallback<T>): () => void;
     onDocModified(callback: DocUpdatedCallback<T>): () => void;
@@ -470,6 +689,11 @@ declare class FlareTransport {
 
 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;
@@ -479,14 +703,19 @@ type ActiveSubscription = {
     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 {
+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[];
@@ -497,6 +726,9 @@ declare class FlareBase {
     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[]>;
@@ -507,8 +739,33 @@ declare class FlareBase {
     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;
+    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;
@@ -548,7 +805,14 @@ declare class FlareBase {
     get isConnected(): boolean;
     onConnectionStateChange(listener: ConnectionListener): () => void;
     onError(callback: ErrorListener): () => void;
-    collection<T = any>(name: string): CollectionReference<T>;
+    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>;
@@ -565,9 +829,12 @@ declare class FlareBase {
     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: QueryConfig | StructuredQuery | undefined, callback: SubscriptionCallback, options?: SubscribeOptions): () => void;
+    subscribe(subId: string, collection: string, docId: string | undefined, query: QueryConfig | StructuredQuery | undefined, callback: SubscriptionCallback, options?: SubscribeOptions): SubscriptionHandle;
     send(type: FlareAction, payload: any): Promise<any>;
     private handleTransportError;
     protected onConnected(): void;
@@ -596,7 +863,7 @@ declare class FlareBase {
  *                 the browser owns two HttpOnly cookies: one from the Flare
  *                 domain and one from the Next.js domain.
  */
-declare class FlareAuth extends FlareBase {
+declare class FlareAuth<TPresetMap extends QueryPresetMap = {}> extends FlareBase<TPresetMap> {
     protected authToken?: string;
     protected userId?: string;
     protected authGuard?: AuthGuard;
@@ -605,9 +872,12 @@ declare class FlareAuth extends FlareBase {
     protected csrfToken?: string;
     protected csrfInitPromise?: Promise<void>;
     protected csrfBootstrapAttempted: boolean;
+    protected socketAuthSyncPromise?: Promise<void>;
+    protected pushServiceWorkerInitPromise?: Promise<ServiceWorkerRegistration | null>;
     protected authSession: FlareAuthSession | null;
     protected authStateListeners: AuthStateListener[];
     protected authConfigListeners: AuthConfigListener[];
+    protected currentProfile: FlareAuthUser | undefined;
     private getDefaultCsrfCookieName;
     getCsrfCookieName(): string;
     /**
@@ -650,13 +920,15 @@ declare class FlareAuth extends FlareBase {
     loadAuthConfig(): Promise<FlareAuthConfig>;
     protected fetchAuthConfig(): Promise<FlareAuthConfig>;
     onAuthConfigLoaded(listener: AuthConfigListener): () => void;
+    protected setProfile(profile: FlareAuthUser): void;
     protected setAuthSession(session: FlareAuthSession | null): void;
     onAuthStateChanged(listener: AuthStateListener): () => void;
     onAuthStateChange(listener: AuthStateListener): () => void;
-    get currentUser(): string | undefined;
-    getCurrentUser(): string | undefined;
+    get currentUser(): FlareAuthUser | undefined;
+    getCurrentUser(): FlareAuthUser | undefined;
     protected syncSocketAuth(accessToken?: string | null): Promise<void>;
     protected updateSocketIdentity(uid?: string, forceReplay?: boolean): Promise<void>;
+    protected beforeActivateSubscription(_entry: any): Promise<void>;
     protected onConnected(): void;
     protected handleIncoming(msg: any): void;
     auth(token: string): Promise<AuthResult>;
@@ -798,6 +1070,39 @@ declare class FlareAuth extends FlareBase {
         email: string;
         sessionsRevoked?: number;
     }>;
+    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>;
+    sendEmail(input: SendEmailInput): Promise<EmailSendResult>;
+    verifyEmailLink(input: VerifyEmailLinkInput): Promise<EmailLinkVerifyResult>;
     signIn(providerId: ProviderId, options?: {
         returnTo?: string;
         metaTag?: string;
@@ -847,7 +1152,9 @@ declare class FlareAuth extends FlareBase {
         additionalParams?: Record<string, string>;
         signInIfAllowed?: boolean;
     }): Promise<Record<string, any>>;
-    protected requestEmailPasswordToken(email: string, password: string, scope?: string[]): Promise<AuthToken>;
+    protected requestEmailPasswordToken(email: string, password: string, scope?: string[]): Promise<AuthToken & {
+        kind: string;
+    }>;
     protected fetchAuthMe(token: string): Promise<{
         id?: string;
         email?: string | null;
@@ -880,8 +1187,11 @@ declare class FlareAuth extends FlareBase {
  * This file wires FlareAuth together and leaves CSRF bootstrapping to the user.
  */
 
-declare class FlareClient extends FlareAuth {
+declare class FlareClient<TPresetMap extends QueryPresetMap = {}> extends FlareAuth<TPresetMap> {
+    private autoPushRegisteredIdentity?;
     constructor(config: FlareConfig);
+    private enableAutoPushNotificationsAfterAuth;
+    autoEnablePushNotifications(): Promise<void>;
 }
 
 /**
@@ -1072,4 +1382,4 @@ declare const getFlare: () => FlareClient | null;
  */
 declare const disconnectFlare: () => void;
 
-export { type AggregateFunction, type AggregateSpec, type AnyFilter, type AuthConfigListener, type AuthConfigResponse, type AuthResult, type AuthStateListener, type AuthWithPendingVerificationResult, type AuthWithTokenResult, type BaseMessage, type ChangeEvent, type ChangeOperation, CollectionReference, type ConnectionState, type CsrfProxyConfig, type CursorValue, type DocAddedCallback, type DocChangedCallback, type DocDeletedCallback, type DocUpdatedCallback, DocumentQueryBuilder, DocumentReference, type DocumentSnapshot, FlareAction, type FlareAuthConfig, type FlareAuthProviderId, type FlareAuthProviderPublicConfig, type FlareAuthSession, type FlareConfig, FlareError, FlareErrors, FlareEvent, FlareResponseCodes, type GroupByClause, type HavingClause, type JoinClause, type OfflineOperation, type OrFilter, type OrderByClause, type PresenceCallback, type PresenceJoinCallback, type PresenceLeaveCallback, type PresenceMember, type QueryConfig, type QueryOperator, type QuerySnapshot, type SnapshotEvent, type StructuredQuery, type SubscribeMessage, type SubscribeOptions, type SubscriptionCallback, type SubscriptionData, type VectorFieldConfig, type VectorSearchClause, type WhereCondition, buildFlareHeaders, connectApp, createCsrfProxy, createCsrfProxyHandler, FlareClient as default, disconnectFlare, extractCsrfFromRequest, getFlare, parseValue, parseWhereCondition };
+export { type AggregateFunction, type AggregateSpec, type AnyFilter, type AuthConfigListener, type AuthConfigResponse, type AuthResult, type AuthStateListener, type AuthWithPendingVerificationResult, type AuthWithTokenResult, type BaseMessage, type BrowserPushRegistrationOptions, type BrowserPushTokenOptions, type ChangeEvent, type ChangeOperation, type CollectionPresetMethods, type CollectionQuery, CollectionReference, type ConnectionState, type CsrfProxyConfig, type CursorValue, type DocAddedCallback, type DocChangedCallback, type DocDeletedCallback, type DocUpdatedCallback, DocumentQueryBuilder, DocumentReference, type DocumentSnapshot, type EmailLinkVerifyResult, type EmailSendResult, FlareAction, type FlareAuthConfig, type FlareAuthProviderId, type FlareAuthProviderPublicConfig, type FlareAuthSession, type FlareAuthUser, type FlareConfig, FlareError, FlareErrors, FlareEvent, FlareResponseCodes, type FlareRule, type GroupByClause, type HavingClause, type JoinClause, type JoinQueryPattern, type NestedJoinClause, type OfflineOperation, type OrFilter, type OrderByClause, type PresenceCallback, type PresenceJoinCallback, type PresenceLeaveCallback, type PresenceMember, type PushSendResult, type QueryConfig, type QueryOperator, type QueryPresetMap, type QueryPresetParams, type QueryPresetRow, type QueryPresetSpec, type QuerySnapshot, type RegisterPushTokenInput, type RulePermission, type SecurityRuleEntry, type SecurityRulesMap, type SendEmailInput, type SendPushNotificationInput, type SnapshotEvent, type StructuredJoinClause, type StructuredQuery, type SubscribeMessage, type SubscribeOptions, type SubscriptionCallback, type SubscriptionData, type SubscriptionError, type SubscriptionErrorCallback, type SubscriptionHandle, type VectorFieldConfig, type VectorSearchClause, type VerifyEmailLinkInput, type WhereCondition, buildFlareHeaders, connectApp, createCsrfProxy, createCsrfProxyHandler, FlareClient as default, disconnectFlare, extractCsrfFromRequest, flareRulesToSecurityMap, getFlare, parseValue, parseWhereCondition, securityMapToFlareRules };