@estra/client 0.0.0-stage → 0.1.1

package/dist/compat/auth.js

@@ -0,0 +1,221 @@
+import { EstraClientError } from "../transport.js";
+import { getApp } from "./app.js";
+/** Firebase's error shape: `name: "FirebaseError"`, `code: "auth/…"`. */
+export class FirebaseError extends Error {
+    code;
+    customData;
+    constructor(code, message) {
+        super(message);
+        this.name = "FirebaseError";
+        this.code = code;
+    }
+}
+const authError = (e) => {
+    if (e instanceof FirebaseError)
+        throw e;
+    if (e instanceof EstraClientError)
+        throw new FirebaseError(e.code.startsWith("auth/") ? e.code : `auth/${e.code === "unavailable" ? "network-request-failed" : e.code}`, e.message);
+    // fetch rejects with a TypeError when the network or CORS blocks the request.
+    if (e instanceof TypeError)
+        throw new FirebaseError("auth/network-request-failed", e.message);
+    throw e;
+};
+const guard = async (p) => {
+    try {
+        return await p();
+    }
+    catch (e) {
+        return authError(e);
+    }
+};
+export class User {
+    providerId = "firebase";
+    phoneNumber = null;
+    tenantId = null;
+    #auth;
+    #u;
+    constructor(auth, u) {
+        this.#auth = auth;
+        this.#u = u;
+        owners.set(this, auth);
+    }
+    get uid() { return this.#u.uid; }
+    get email() { return this.#u.email; }
+    get emailVerified() { return this.#u.emailVerified; }
+    get displayName() { return this.#u.displayName; }
+    get photoURL() { return this.#u.photoUrl; }
+    get isAnonymous() { return this.#u.anonymous; }
+    get providerData() {
+        return this.#u.providers.map((providerId) => ({ uid: this.#u.uid, providerId, email: this.#u.email, displayName: this.#u.displayName, photoURL: this.#u.photoUrl, phoneNumber: null }));
+    }
+    get metadata() {
+        return { creationTime: new Date(this.#u.createdAt).toUTCString(), lastSignInTime: this.#u.lastSignInAt ? new Date(this.#u.lastSignInAt).toUTCString() : undefined };
+    }
+    /** @internal */ _update(u) { this.#u = u; }
+    async getIdToken(forceRefresh = false) {
+        const t = await guard(() => this.#auth._estra.getIdToken(forceRefresh));
+        if (!t)
+            throw new FirebaseError("auth/user-token-expired", "the user is signed out");
+        return t;
+    }
+    async getIdTokenResult(forceRefresh = false) {
+        const token = await this.getIdToken(forceRefresh);
+        const claims = JSON.parse(atob(token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")));
+        return { token, claims, authTime: new Date(Number(claims.auth_time ?? claims.iat) * 1000).toUTCString(), issuedAtTime: new Date(Number(claims.iat) * 1000).toUTCString(), expirationTime: new Date(Number(claims.exp) * 1000).toUTCString(), signInProvider: null, signInSecondFactor: null };
+    }
+    async reload() {
+        await this.getIdToken(true);
+    }
+    async delete() {
+        await guard(() => this.#auth._estra.deleteUser());
+    }
+    toJSON() {
+        return { uid: this.uid, email: this.email, emailVerified: this.emailVerified, displayName: this.displayName, photoURL: this.photoURL, isAnonymous: this.isAnonymous };
+    }
+}
+export class Auth {
+    app;
+    name;
+    _estra;
+    languageCode = null;
+    #user = null;
+    constructor(app) {
+        this.app = app;
+        this.name = app.name;
+        this._estra = app._estra.auth;
+        // Keep one User object per signed-in uid, as Firebase does, and tell live listeners.
+        this._estra.onAuthStateChanged((u) => {
+            this._wrap(u);
+            app._estra.transport.refreshAuth?.();
+        });
+    }
+    get currentUser() {
+        return this._wrap(this._estra.currentUser);
+    }
+    /** @internal */ _wrap(u) {
+        if (!u)
+            return (this.#user = null);
+        if (this.#user?.uid === u.uid)
+            this.#user._update(u);
+        else
+            this.#user = new User(this, u);
+        return this.#user;
+    }
+    authStateReady() {
+        return this._estra.ready();
+    }
+    onAuthStateChanged(next) {
+        return onAuthStateChanged(this, next);
+    }
+    signOut() {
+        return signOut(this);
+    }
+}
+const instances = new WeakMap();
+export function getAuth(app = getApp()) {
+    let a = instances.get(app);
+    if (!a)
+        instances.set(app, (a = new Auth(app)));
+    return a;
+}
+export const initializeAuth = (app, _deps) => getAuth(app);
+// Persistence options are accepted for compatibility; the session lives in localStorage.
+export const browserLocalPersistence = { type: "LOCAL" };
+export const browserSessionPersistence = { type: "SESSION" };
+export const inMemoryPersistence = { type: "NONE" };
+export const indexedDBLocalPersistence = { type: "LOCAL" };
+export const setPersistence = async (_auth, _p) => { };
+export function onAuthStateChanged(auth, next, _error) {
+    const cb = typeof next === "function" ? next : (u) => next.next?.(u);
+    return auth._estra.onAuthStateChanged((u) => cb(auth._wrap(u)));
+}
+export const onIdTokenChanged = onAuthStateChanged;
+export const beforeAuthStateChanged = (_auth, _cb) => () => { };
+const isNew = (u) => u.lastSignInAt === null || u.lastSignInAt - u.createdAt < 10_000;
+const credential = (auth, u, providerId, isNewUser, operationType = "signIn") => ({ user: auth._wrap(u), providerId, operationType, _isNewUser: isNewUser });
+export const signInWithEmailAndPassword = (auth, email, password) => guard(async () => credential(auth, await auth._estra.signIn(email, password), null, false));
+export const createUserWithEmailAndPassword = (auth, email, password) => guard(async () => credential(auth, await auth._estra.signUp(email, password), null, true));
+export const signInAnonymously = (auth) => guard(async () => credential(auth, await auth._estra.signInAnonymously(), null, true));
+export const signOut = (auth) => guard(() => auth._estra.signOut());
+export const sendPasswordResetEmail = (auth, email, _settings) => guard(async () => void (await auth._estra.sendPasswordReset(email)));
+export const confirmPasswordReset = (auth, oobCode, newPassword) => guard(async () => void (await auth._estra.confirmPasswordReset(oobCode, newPassword)));
+export const sendSignInLinkToEmail = (auth, email, _settings) => guard(async () => void (await auth._estra.sendSignInLink(email)));
+export const signInWithEmailLink = (auth, _email, link) => guard(async () => credential(auth, await auth._estra.signInWithLink(new URL(link).searchParams.get("oobCode") ?? ""), "emailLink", false));
+export const isSignInWithEmailLink = (_auth, link) => {
+    try {
+        return new URL(link).searchParams.get("mode") === "signIn";
+    }
+    catch {
+        return false;
+    }
+};
+export const sendEmailVerification = (user, _settings) => guard(async () => void (await authOf(user)._estra.sendEmailVerification()));
+export const applyActionCode = (auth, oobCode) => guard(() => auth._estra.applyEmailVerification(oobCode));
+const owners = new WeakMap();
+function authOf(user) {
+    return owners.get(user) ?? getAuth();
+}
+export const updateProfile = (user, p) => guard(async () => {
+    const u = await authOf(user)._estra.updateProfile({ ...(p.displayName !== undefined ? { displayName: p.displayName } : {}), ...(p.photoURL !== undefined ? { photoUrl: p.photoURL } : {}) });
+    user._update(u);
+});
+export const updatePassword = (user, newPassword) => guard(async () => void (await authOf(user)._estra.updateProfile({ password: newPassword })));
+export const deleteUser = (user) => user.delete();
+class ProviderBase {
+    providerId;
+    constructor(id) {
+        this.providerId = id;
+    }
+    // Scopes and custom parameters are fixed server-side (deploy config).
+    addScope(_s) {
+        return this;
+    }
+    setCustomParameters(_p) {
+        return this;
+    }
+}
+export class GoogleAuthProvider extends ProviderBase {
+    static PROVIDER_ID = "google.com";
+    constructor() {
+        super("google.com");
+    }
+}
+export class GithubAuthProvider extends ProviderBase {
+    static PROVIDER_ID = "github.com";
+    constructor() {
+        super("github.com");
+    }
+}
+export class OAuthProvider extends ProviderBase {
+    constructor(id) {
+        if (id !== "apple.com" && id !== "google.com" && id !== "github.com")
+            throw new FirebaseError("auth/invalid-provider-id", `${id} isn't supported`);
+        super(id);
+    }
+}
+export const signInWithPopup = (auth, provider, _resolver) => {
+    // The popup must open synchronously in the click handler: call before any await.
+    const p = auth._estra.signInWithPopup(provider.providerId);
+    return guard(async () => {
+        const u = await p;
+        return credential(auth, u, provider.providerId, isNew(u));
+    });
+};
+export const linkWithPopup = (user, provider) => {
+    const auth = authOf(user);
+    const p = auth._estra.linkWithPopup(provider.providerId);
+    return guard(async () => credential(auth, await p, provider.providerId, false, "link"));
+};
+export const reauthenticateWithPopup = (user, provider) => {
+    const auth = authOf(user);
+    const p = auth._estra.reauthenticateWithPopup(provider.providerId);
+    return guard(async () => credential(auth, await p, provider.providerId, false, "reauthenticate"));
+};
+export const signInWithRedirect = (auth, provider) => guard(async () => auth._estra.signInWithRedirect(provider.providerId));
+export const getRedirectResult = (auth) => guard(async () => {
+    const u = await auth._estra.getRedirectResult();
+    return u ? credential(auth, u, null, isNew(u)) : null;
+});
+export function getAdditionalUserInfo(cred) {
+    return cred ? { isNewUser: cred._isNewUser, providerId: cred.providerId, profile: null } : null;
+}

package/dist/compat/firestore.d.ts

@@ -0,0 +1,18 @@
+import { type Firestore } from "../firestore.js";
+import { type Transport } from "../transport.js";
+import { type FirebaseApp } from "./app.js";
+export * from "../firestore.js";
+/** Settings for an Estra-backed Firestore on any app object (e.g. a real Firebase app). */
+export interface EstraFirestoreSettings {
+    estraUrl: string;
+    /** The signed-in user's ID token, or null when signed out. */
+    getToken: () => Promise<string | null> | string | null;
+    /** Called with a listener for sign-in changes, so live listeners switch user at once. */
+    onTokenChange?: (cb: () => void) => unknown;
+    fetch?: typeof fetch;
+    WebSocket?: typeof WebSocket;
+}
+export declare function getFirestore(app?: FirebaseApp | Transport | {
+    transport: Transport;
+} | object): Firestore;
+export declare function initializeFirestore(app: object, settings?: Partial<EstraFirestoreSettings> | Record<string, unknown>): Firestore;

package/dist/compat/firestore.js

@@ -0,0 +1,43 @@
+// Firebase-compatible `firebase/firestore`: Estra's Firestore API, with getFirestore(app) taking
+// the app from ./app.ts (its transport carries the signed-in user's token).
+//
+// Data on Estra, sign-in still on Firebase: alias only firebase/firestore, keep the real
+// firebase/app + firebase/auth, and connect with the Firebase user's ID token:
+//   const db = initializeFirestore(app, {
+//     estraUrl, getToken: () => auth.currentUser?.getIdToken() ?? null,
+//     onTokenChange: (cb) => onIdTokenChanged(auth, cb),
+//   });
+// (The server must accept Firebase tokens: defineAuth({ firebaseTokens: { projectId } }).)
+import { getFirestore as fromTransport } from "../firestore.js";
+import { offline } from "../offline.js";
+import { httpTransport } from "../transport.js";
+import { getApp } from "./app.js";
+export * from "../firestore.js";
+const instances = new WeakMap();
+export function getFirestore(app) {
+    const key = app ?? getApp();
+    let db = instances.get(key);
+    if (!db) {
+        if ("_estra" in key)
+            db = fromTransport(key._estra.transport);
+        else if ("getAll" in key || "transport" in key)
+            db = fromTransport(key);
+        else
+            throw new Error("getFirestore: this app has no Estra connection; call initializeFirestore(app, { estraUrl, getToken }) first");
+        instances.set(key, db);
+    }
+    return db;
+}
+export function initializeFirestore(app, settings) {
+    const s = (settings ?? {});
+    if ("_estra" in app || !s.estraUrl || !s.getToken)
+        return getFirestore(app);
+    const existing = instances.get(app);
+    if (existing)
+        return existing;
+    const transport = offline(httpTransport({ url: s.estraUrl, getToken: s.getToken, ...(s.fetch ? { fetch: s.fetch } : {}), ...(s.WebSocket ? { WebSocket: s.WebSocket } : {}) }));
+    s.onTokenChange?.(() => transport.refreshAuth?.());
+    const db = fromTransport(transport);
+    instances.set(app, db);
+    return db;
+}

package/dist/compat/storage.d.ts

@@ -0,0 +1,5 @@
+import { type FirebaseApp } from "./app.js";
+export interface FirebaseStorage {
+    readonly app: FirebaseApp;
+}
+export declare const getStorage: (app?: FirebaseApp) => FirebaseStorage;

package/dist/compat/storage.js

@@ -0,0 +1,5 @@
+// Firebase-compatible `firebase/storage` stub: getStorage(app) returns a handle. Apps that upload
+// through their own endpoint (presigned R2 URLs) only need it to exist; Estra's storage plugin
+// has its own client in @estra/client/storage.
+import { getApp } from "./app.js";
+export const getStorage = (app = getApp()) => ({ app });

package/dist/firestore.d.ts

@@ -0,0 +1,256 @@
+import type { DocOut, Filter, Order, Query as QueryAst, Sentinel, Write } from "./_schema/index.js";
+import { EstraClientError, type Transport } from "./transport.js";
+export type DocumentData = Record<string, any>;
+export { EstraClientError as FirestoreError };
+export declare class Timestamp {
+    readonly seconds: number;
+    readonly nanoseconds: number;
+    constructor(seconds: number, nanoseconds: number);
+    static now(): Timestamp;
+    static fromDate(d: Date): Timestamp;
+    static fromMillis(ms: number): Timestamp;
+    toMillis(): number;
+    toDate(): Date;
+    isEqual(o: Timestamp): boolean;
+    valueOf(): string;
+    toJSON(): {
+        seconds: number;
+        nanoseconds: number;
+    };
+}
+export declare class GeoPoint {
+    readonly latitude: number;
+    readonly longitude: number;
+    constructor(latitude: number, longitude: number);
+    isEqual(o: GeoPoint): boolean;
+}
+export declare class FieldValue {
+    readonly wire: Sentinel;
+    constructor(wire: Sentinel);
+}
+export declare const serverTimestamp: () => FieldValue;
+export declare const increment: (n: number) => FieldValue;
+export declare const arrayUnion: (...values: unknown[]) => FieldValue;
+export declare const arrayRemove: (...values: unknown[]) => FieldValue;
+export declare const deleteField: () => FieldValue;
+export declare class FieldPath {
+    readonly segments: string[];
+    constructor(...segments: string[]);
+}
+export declare const documentId: () => FieldPath;
+export declare class Firestore {
+    readonly type = "firestore";
+    readonly transport: Transport;
+    constructor(transport: Transport);
+}
+export declare const getFirestore: (t: Transport | {
+    transport: Transport;
+}) => Firestore;
+export declare const autoId: () => string;
+export declare class DocumentReference<T = DocumentData> {
+    readonly type = "document";
+    readonly firestore: Firestore;
+    readonly path: string;
+    readonly __t?: T;
+    constructor(firestore: Firestore, path: string);
+    get id(): string;
+    get parent(): CollectionReference<T>;
+}
+interface QState {
+    from?: string;
+    group?: string;
+    where: Filter[];
+    orderBy: Order[];
+    limit?: number;
+    limitToLast?: number;
+    startAfter?: unknown[];
+    startAt?: unknown[];
+    endAt?: unknown[];
+    endBefore?: unknown[];
+    near?: {
+        field: string;
+        lat: number;
+        lng: number;
+        radiusMi: number;
+    };
+}
+export declare class Query<T = DocumentData> {
+    readonly type: "query" | "collection";
+    readonly firestore: Firestore;
+    readonly state: QState;
+    readonly __t?: T;
+    constructor(firestore: Firestore, state: QState);
+    ast(): QueryAst;
+}
+export declare class CollectionReference<T = DocumentData> extends Query<T> {
+    readonly type = "collection";
+    readonly path: string;
+    constructor(firestore: Firestore, path: string);
+    get id(): string;
+    get parent(): DocumentReference | null;
+}
+export declare function doc(parent: Firestore | CollectionReference<any> | DocumentReference<any>, path?: string, ...more: string[]): DocumentReference;
+export declare function collection(parent: Firestore | DocumentReference<any> | CollectionReference<any>, path: string, ...more: string[]): CollectionReference;
+export declare const collectionGroup: (db: Firestore, id: string) => Query<DocumentData>;
+type FieldArg = string | FieldPath;
+export declare class QueryConstraint {
+    readonly apply: (s: QState) => QState;
+    constructor(apply: (s: QState) => QState);
+}
+export declare class QueryFilterConstraint extends QueryConstraint {
+    readonly filter: Filter;
+    constructor(filter: Filter);
+}
+export type WhereFilterOp = "<" | "<=" | "==" | "!=" | ">=" | ">" | "array-contains" | "in" | "array-contains-any" | "not-in";
+export declare function where(field: FieldArg, op: WhereFilterOp, value: unknown): QueryFilterConstraint;
+export declare const and: (...fs: QueryFilterConstraint[]) => QueryFilterConstraint;
+export declare const or: (...fs: QueryFilterConstraint[]) => QueryFilterConstraint;
+export declare const orderBy: (field: FieldArg, dir?: "asc" | "desc") => QueryConstraint;
+export declare const limit: (n: number) => QueryConstraint;
+/** The last n results in orderBy order (needs an orderBy). */
+export declare const limitToLast: (n: number) => QueryConstraint;
+export declare const startAfter: (...args: unknown[]) => QueryConstraint;
+export declare const startAt: (...args: unknown[]) => QueryConstraint;
+/**
+ * Radius search (an Estra addition): documents whose geo field is within `radiusMi` of `center`.
+ * Without an orderBy, results sort by distance; each snapshot's `distanceMi` says how far. Works
+ * in listeners too (moving documents enter and leave the results).
+ */
+export declare const near: (field: FieldArg, center: GeoPoint | {
+    lat: number;
+    lng: number;
+}, radiusMi: number) => QueryConstraint;
+export declare const endAt: (...args: unknown[]) => QueryConstraint;
+export declare const endBefore: (...args: unknown[]) => QueryConstraint;
+export declare function query<T>(q: Query<T>, ...constraints: QueryConstraint[]): Query<T>;
+export interface SnapshotMetadata {
+    hasPendingWrites: boolean;
+    fromCache: boolean;
+    isEqual(o: SnapshotMetadata): boolean;
+}
+export declare class DocumentSnapshot<T = DocumentData> {
+    readonly ref: DocumentReference<T>;
+    readonly metadata: SnapshotMetadata;
+    readonly _raw: DocOut | null;
+    constructor(ref: DocumentReference<T>, raw: DocOut | null, m?: {
+        fromCache: boolean;
+        hasPendingWrites: boolean;
+    });
+    get id(): string;
+    exists(): boolean;
+    /** For `near` queries: miles from the query's center (an Estra addition). */
+    get distanceMi(): number | undefined;
+    data(): T | undefined;
+    get(field: FieldArg): any;
+}
+export declare class QueryDocumentSnapshot<T = DocumentData> extends DocumentSnapshot<T> {
+    data(): T;
+}
+export interface DocumentChange<T = DocumentData> {
+    type: "added" | "modified" | "removed";
+    doc: QueryDocumentSnapshot<T>;
+    oldIndex: number;
+    newIndex: number;
+}
+export declare class QuerySnapshot<T = DocumentData> {
+    readonly query: Query<T>;
+    readonly docs: QueryDocumentSnapshot<T>[];
+    readonly metadata: SnapshotMetadata;
+    private readonly changes;
+    constructor(q: Query<T>, docs: QueryDocumentSnapshot<T>[], changes?: DocumentChange<T>[] | null, m?: {
+        fromCache: boolean;
+        hasPendingWrites: boolean;
+    });
+    /** Changes since the previous snapshot of a listener (all "added" for a one-off read). */
+    docChanges(): DocumentChange<T>[];
+    get size(): number;
+    get empty(): boolean;
+    forEach(cb: (d: QueryDocumentSnapshot<T>) => void): void;
+}
+export declare function getDoc<T>(ref: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
+export declare function getDocs<T>(q: Query<T>): Promise<QuerySnapshot<T>>;
+export declare const waitForPendingWrites: (db: Firestore) => Promise<void>;
+export declare const disableNetwork: (db: Firestore) => Promise<void>;
+export declare const enableNetwork: (db: Firestore) => Promise<void>;
+export declare const clearIndexedDbPersistence: (db: Firestore) => Promise<void>;
+export declare const clearPersistence: (db: Firestore) => Promise<void>;
+export declare function getCountFromServer(q: Query<any>): Promise<{
+    data: () => {
+        count: number;
+    };
+}>;
+type AggSpec = {
+    kind: "count";
+} | {
+    kind: "sum" | "avg";
+    field: string;
+};
+export declare const count: () => AggSpec;
+export declare const sum: (field: string) => AggSpec;
+export declare const average: (field: string) => AggSpec;
+export declare function getAggregateFromServer(q: Query<any>, spec: Record<string, AggSpec>): Promise<{
+    data: () => {
+        [k: string]: number | null;
+    };
+}>;
+/**
+ * Live aggregates (an Estra addition; Firestore has none): calls `next` with the current values,
+ * then again whenever a matching document changes them. Same rules and caps as getAggregateFromServer.
+ *   onAggregateSnapshot(query(collection(db, "orders"), where("open", "==", true)), { n: count(), total: sum("amount") }, (s) => show(s.data()))
+ */
+export declare function onAggregateSnapshot<S extends Record<string, AggSpec>>(q: Query<any>, spec: S, next: (s: {
+    data(): {
+        [K in keyof S]: number | null;
+    };
+}) => void, error?: (e: EstraClientError) => void): Unsubscribe;
+export interface SetOptions {
+    merge?: boolean;
+}
+/**
+ * Hot counters: adds `by` to a number field through the server's counter buffer (one commit about
+ * every second, however many calls). Resolves with the new value (stored + buffered). Needs
+ * `createEstra({ counters })`, and passes the document's update rule per call. Online only.
+ */
+export declare function incrementBuffered(ref: DocumentReference<any>, field: string | FieldPath, by?: number): Promise<number | null>;
+export declare const setDoc: (ref: DocumentReference<any>, data: DocumentData, o?: SetOptions) => Promise<void>;
+export declare const updateDoc: (ref: DocumentReference<any>, a: DocumentData | FieldArg, ...rest: unknown[]) => Promise<void>;
+export declare const deleteDoc: (ref: DocumentReference<any>) => Promise<void>;
+export declare function addDoc<T>(coll: CollectionReference<T>, data: DocumentData): Promise<DocumentReference<T>>;
+export declare class WriteBatch {
+    readonly db: Firestore;
+    readonly writes: Write[];
+    constructor(db: Firestore);
+    set(ref: DocumentReference<any>, data: DocumentData, o?: SetOptions): this;
+    update(ref: DocumentReference<any>, a: DocumentData | FieldArg, ...rest: unknown[]): this;
+    delete(ref: DocumentReference<any>): this;
+    commit(): Promise<void>;
+}
+export declare const writeBatch: (db: Firestore) => WriteBatch;
+export declare class Transaction {
+    readonly db: Firestore;
+    readonly reads: Map<string, number>;
+    readonly writes: Write[];
+    constructor(db: Firestore);
+    get<T>(ref: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
+    set(ref: DocumentReference<any>, data: DocumentData, o?: SetOptions): this;
+    update(ref: DocumentReference<any>, a: DocumentData | FieldArg, ...rest: unknown[]): this;
+    delete(ref: DocumentReference<any>): this;
+}
+/** Reads, then writes guarded on the versions read; retried when a read went stale. */
+export declare function runTransaction<R>(db: Firestore, fn: (t: Transaction) => Promise<R>, o?: {
+    maxAttempts?: number;
+}): Promise<R>;
+type Observer<S> = {
+    next?: (s: S) => void;
+    error?: (e: EstraClientError) => void;
+    complete?: () => void;
+};
+export type Unsubscribe = () => void;
+export declare function onSnapshot<T>(ref: DocumentReference<T>, next: ((s: DocumentSnapshot<T>) => void) | Observer<DocumentSnapshot<T>>, error?: (e: EstraClientError) => void): Unsubscribe;
+export declare function onSnapshot<T>(q: Query<T>, next: ((s: QuerySnapshot<T>) => void) | Observer<QuerySnapshot<T>>, error?: (e: EstraClientError) => void): Unsubscribe;
+export declare function onSnapshot<T>(ref: DocumentReference<T>, options: {
+    includeMetadataChanges?: boolean;
+}, next: (s: DocumentSnapshot<T>) => void, error?: (e: EstraClientError) => void): Unsubscribe;
+export declare function onSnapshot<T>(q: Query<T>, options: {
+    includeMetadataChanges?: boolean;
+}, next: (s: QuerySnapshot<T>) => void, error?: (e: EstraClientError) => void): Unsubscribe;