@estra/client 0.0.0-stage → 0.1.0

package/dist/auth.js

@@ -0,0 +1,245 @@
+// Client auth for an Estra app: sign-in methods, a persisted session, ID tokens refreshed before
+// they expire, and onAuthStateChanged. Pair it with the Firestore API:
+//   const auth = createAuth({ url });
+//   const db = getFirestore(httpTransport({ url, getToken: () => auth.getIdToken() }));
+import { EstraClientError } from "./transport.js";
+export const memoryStorage = () => {
+    const m = new Map();
+    return { get: (k) => m.get(k) ?? null, set: (k, v) => void m.set(k, v), remove: (k) => void m.delete(k) };
+};
+const webStorage = () => globalThis.localStorage;
+export const browserStorage = () => ({
+    get: (k) => webStorage()?.getItem(k) ?? null,
+    set: (k, v) => webStorage()?.setItem(k, v),
+    remove: (k) => webStorage()?.removeItem(k),
+});
+export function createAuth(o) {
+    const base = o.url.replace(/\/$/, "");
+    const storage = o.storage ?? (webStorage() ? browserStorage() : memoryStorage());
+    const f = o.fetch ?? ((...a) => fetch(...a));
+    const margin = o.refreshMarginMs ?? 5 * 60_000;
+    const key = `estra.session:${base}`;
+    const listeners = new Set();
+    const win = () => o.window ?? globalThis.window ?? fail("no window: popup/redirect sign-in needs a browser");
+    const slug = (p) => p.replace(/\.com$/, "");
+    const startUrl = (p, q) => `${base}/v1/auth/oauth/${slug(p)}/start?${new URLSearchParams(q)}`;
+    const estraOrigin = new URL(base).origin;
+    /** Opens the provider popup (synchronously, so browsers allow it) and resolves with the one-time code. */
+    function popupCode(p, linkToken) {
+        const w = win();
+        const popup = w.open(linkToken ? "about:blank" : startUrl(p, { mode: "popup", origin: w.location.origin }), "estra-auth", "popup,width=500,height=640");
+        if (!popup)
+            return Promise.reject(new EstraClientError("popup-blocked", "the browser blocked the sign-in popup"));
+        return new Promise((resolve, reject) => {
+            let done = false;
+            const finish = (err, code) => {
+                if (done)
+                    return;
+                done = true;
+                clearInterval(timer);
+                w.removeEventListener("message", onMessage);
+                if (err)
+                    reject(err);
+                else
+                    resolve(code);
+            };
+            const onMessage = (e) => {
+                if (e.origin !== estraOrigin)
+                    return;
+                const d = e.data;
+                if (d?.type !== "estra-oauth")
+                    return;
+                if (d.code)
+                    finish(null, d.code);
+                else
+                    finish(new EstraClientError(d.error?.code ?? "internal", d.error?.message ?? "sign-in failed"));
+            };
+            w.addEventListener("message", onMessage);
+            const timer = setInterval(() => {
+                if (popup.closed)
+                    finish(new EstraClientError("popup-closed-by-user", "the sign-in popup was closed"));
+            }, 400);
+            if (linkToken)
+                linkToken.then((t) => (popup.location.href = startUrl(p, { mode: "popup", origin: w.location.origin, linkToken: t })), (e) => {
+                    popup.close();
+                    finish(e instanceof EstraClientError ? e : new EstraClientError("internal", String(e)));
+                });
+        });
+    }
+    let session = null;
+    let loaded = null;
+    let refreshing = null;
+    const emit = () => listeners.forEach((l) => l(session?.user ?? null));
+    async function load() {
+        loaded ??= (async () => {
+            const raw = await storage.get(key);
+            try {
+                session = raw ? JSON.parse(raw) : null;
+            }
+            catch {
+                session = null;
+            }
+        })();
+        return loaded;
+    }
+    async function save(s) {
+        session = s;
+        if (s)
+            await storage.set(key, JSON.stringify(s));
+        else
+            await storage.remove(key);
+        emit();
+    }
+    async function post(route, body, bearer) {
+        const headers = { "content-type": "application/json" };
+        if (bearer)
+            headers.authorization = `Bearer ${bearer}`;
+        const r = await f(`${base}/v1/auth/${route}`, { method: "POST", headers, body: JSON.stringify(body) });
+        const j = (await r.json().catch(() => ({})));
+        if (!r.ok)
+            throw new EstraClientError(j.error?.code ?? "unavailable", j.error?.message ?? `HTTP ${r.status}`);
+        return j;
+    }
+    const start = async (p) => {
+        const s = await p;
+        await save({ idToken: s.idToken, refreshToken: s.refreshToken, expiresAt: Date.now() + s.expiresIn * 1000, user: s.user });
+        return s.user;
+    };
+    async function refresh() {
+        refreshing ??= (async () => {
+            const cur = session;
+            if (!cur)
+                return null;
+            try {
+                const s = await post("refresh", { refreshToken: cur.refreshToken });
+                await save({ idToken: s.idToken, refreshToken: s.refreshToken, expiresAt: Date.now() + s.expiresIn * 1000, user: s.user });
+                return session;
+            }
+            catch (e) {
+                // Only a refusal signs out; a network failure keeps the session for the next try.
+                if (e instanceof EstraClientError && e.code === "invalid-credential")
+                    await save(null);
+                throw e;
+            }
+        })().finally(() => {
+            refreshing = null;
+        });
+        return refreshing;
+    }
+    async function linkToken() {
+        const token = await currentToken();
+        return (await post("oauth/link-token", {}, token)).linkToken;
+    }
+    return {
+        get currentUser() {
+            return session?.user ?? null;
+        },
+        /** Resolves once the stored session (if any) is loaded. */
+        ready: () => load(),
+        onAuthStateChanged(cb) {
+            listeners.add(cb);
+            void load().then(() => cb(session?.user ?? null));
+            return () => listeners.delete(cb);
+        },
+        /** A valid access token (refreshed when near expiry), or null when signed out. */
+        async getIdToken(forceRefresh = false) {
+            await load();
+            if (!session)
+                return null;
+            if (forceRefresh || session.expiresAt - Date.now() < margin)
+                return (await refresh())?.idToken ?? null;
+            return session.idToken;
+        },
+        signUp: async (email, password, displayName) => {
+            await load();
+            return start(post("signup", { email, password, ...(displayName ? { displayName } : {}) }, session?.user.anonymous ? session.idToken : undefined));
+        },
+        signIn: (email, password) => start(post("signin", { email, password })),
+        /** Google/Apple: pass the ID token from Google Identity Services or Sign in with Apple. */
+        signInWithIdToken: (provider, idToken, o = {}) => start(post("signin/idp", { provider, idToken, ...o })),
+        signInAnonymously: () => start(post("signin/anonymous", {})),
+        /** Google / Apple / GitHub in a popup (call from a click handler). */
+        signInWithPopup: async (provider) => start(post("oauth/exchange", { code: await popupCode(provider) })),
+        // Popups must open synchronously inside the click handler (browsers block them after an await),
+        // so every popup flow opens first and does its async work afterwards.
+        /** Link a provider to the signed-in account (an anonymous account becomes a full one, same uid). */
+        linkWithPopup: async (provider) => start(post("oauth/exchange", { code: await popupCode(provider, linkToken()) })),
+        /** Sign in again with the same account (before sensitive changes). Fails if a different account answers. */
+        reauthenticateWithPopup: async (provider) => {
+            const codeP = popupCode(provider);
+            await load();
+            const uid = session?.user.uid;
+            const code = await codeP;
+            if (!uid)
+                throw new EstraClientError("unauthenticated", "sign in first");
+            const s = await post("oauth/exchange", { code });
+            if (s.uid !== uid)
+                throw new EstraClientError("user-mismatch", "a different account signed in");
+            return start(Promise.resolve(s));
+        },
+        /** Full-page redirect sign-in; finish with getRedirectResult() on the page you return to. */
+        signInWithRedirect: (provider, returnTo) => {
+            const w = win();
+            w.location.assign(startUrl(provider, { mode: "redirect", returnTo: returnTo ?? w.location.href }));
+        },
+        linkWithRedirect: async (provider, returnTo) => {
+            const w = win();
+            w.location.assign(startUrl(provider, { mode: "redirect", returnTo: returnTo ?? w.location.href, linkToken: await linkToken() }));
+        },
+        /** After a redirect: the signed-in user, null when this page load isn't a sign-in return. */
+        getRedirectResult: async () => {
+            const w = win();
+            const h = new URLSearchParams(w.location.hash.replace(/^#/, ""));
+            const code = h.get("estra_auth");
+            const error = h.get("estra_auth_error");
+            if (!code && !error)
+                return null;
+            w.history?.replaceState(null, "", w.location.href.split("#")[0]);
+            if (error)
+                throw new EstraClientError(error, "sign-in failed");
+            return start(post("oauth/exchange", { code }));
+        },
+        /** Native apps: link a Google/Apple ID token to the signed-in account. */
+        linkWithIdToken: async (provider, idToken, nonce) => start(post("link/idp", { provider, idToken, ...(nonce ? { nonce } : {}) }, await currentToken())),
+        sendSignInLink: (email) => post("email/send", { mode: "signIn", email }),
+        /** Finish a link from the email: mode + oobCode come from its query string. */
+        signInWithLink: (oobCode) => start(post("email/confirm", { mode: "signIn", oobCode })),
+        sendPasswordReset: (email) => post("email/send", { mode: "resetPassword", email }),
+        confirmPasswordReset: (oobCode, newPassword) => post("email/confirm", { mode: "resetPassword", oobCode, newPassword }),
+        sendEmailVerification: async () => post("email/send", { mode: "verifyEmail" }, (await load(), session?.idToken)),
+        applyEmailVerification: async (oobCode) => {
+            await post("email/confirm", { mode: "verifyEmail", oobCode });
+            if (session)
+                await refresh().catch(() => null);
+        },
+        updateProfile: async (p) => {
+            const token = await currentToken();
+            const { user } = await post("me/update", p, token);
+            if (session)
+                await save({ ...session, user });
+            return user;
+        },
+        deleteUser: async () => {
+            await post("me/delete", {}, await currentToken());
+            await save(null);
+        },
+        signOut: async () => {
+            await load();
+            const s = session;
+            await save(null);
+            if (s)
+                await post("signout", { refreshToken: s.refreshToken }).catch(() => null);
+        },
+    };
+    async function currentToken() {
+        await load();
+        if (!session)
+            throw new EstraClientError("unauthenticated", "sign in first");
+        if (session.expiresAt - Date.now() < margin)
+            await refresh();
+        return session.idToken;
+    }
+}
+function fail(message, code = "internal") {
+    throw new EstraClientError(code, message);
+}

package/dist/channels.d.ts

@@ -0,0 +1,42 @@
+export interface Member {
+    /** Per connection; changes after a reconnect. */
+    id: string;
+    uid: string | null;
+    state: unknown;
+}
+export interface ChannelOptions {
+    url: string;
+    getToken?: () => Promise<string | null> | string | null;
+    WebSocket?: typeof WebSocket;
+}
+export type PresenceEvent = {
+    event: "join" | "leave" | "update" | "sync";
+    member?: Member;
+};
+type Unsubscribe = () => void;
+export declare class ChannelError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface Channel {
+    readonly name: string;
+    /** Joins (or re-joins) with a presence state; resolves with you and the members present. */
+    join(state?: unknown): Promise<{
+        self: Member;
+        members: Member[];
+    }>;
+    /** Replaces your presence state (others get a presence "update"). */
+    setState(state: unknown): void;
+    /** To every other member. */
+    broadcast(event: string, data?: unknown): void;
+    /** To one member (by member id). */
+    send(to: string, event: string, data?: unknown): void;
+    on(event: string, fn: (data: any, from: Member) => void): Unsubscribe;
+    onPresence(fn: (members: Member[], change: PresenceEvent) => void): Unsubscribe;
+    onError(fn: (e: ChannelError) => void): Unsubscribe;
+    members(): Member[];
+    self(): Member | null;
+    leave(): void;
+}
+export declare function channel(o: ChannelOptions, name: string): Channel;
+export {};

package/dist/channels.js

@@ -0,0 +1,176 @@
+// Ephemeral channels: presence, broadcast and direct messages (/v1/channels/<name>).
+//
+//   const room = channel({ url, getToken }, "room:42");
+//   room.onPresence((members) => render(members));
+//   room.on("cursor", (pos, from) => moveCursor(from.id, pos));
+//   await room.join({ name: "Ann" });
+//   room.broadcast("cursor", { x, y });
+//   room.setState({ name: "Ann", typing: true });
+//   room.send(memberId, "offer", sdp);   // WebRTC signalling
+//   room.leave();
+//
+// The socket reconnects with backoff and joins again with the last state (members get new ids
+// then: others see a leave and a join). Nothing here is stored: use documents for history.
+export class ChannelError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ChannelError";
+    }
+}
+export function channel(o, name) {
+    const WS = o.WebSocket ?? globalThis.WebSocket;
+    const url = `${o.url.replace(/^http/, "ws").replace(/\/$/, "")}/v1/channels/${encodeURIComponent(name)}`;
+    const handlers = new Map();
+    const presence = new Set();
+    const errors = new Set();
+    const members = new Map();
+    let me = null;
+    let ws = null;
+    let ready = false;
+    let wantJoin = false;
+    let state = undefined;
+    let backoff = 500;
+    let left = false;
+    let joining = null;
+    const queue = [];
+    const raw = (m) => {
+        const s = JSON.stringify(m);
+        if (ws && ready && me)
+            ws.send(s);
+        else
+            queue.push(s);
+    };
+    const emitPresence = (change) => {
+        const list = [...members.values()];
+        for (const f of presence)
+            f(list, change);
+    };
+    const fail = (e) => {
+        if (joining) {
+            joining.reject(e);
+            joining = null;
+        }
+        for (const f of errors)
+            f(e);
+    };
+    const auth = async () => ws?.send(JSON.stringify({ t: "auth", token: o.getToken ? await o.getToken() : null }));
+    function open() {
+        if (ws || left)
+            return;
+        if (!WS)
+            throw new Error("no WebSocket available: pass ChannelOptions.WebSocket");
+        const sock = new WS(url);
+        ws = sock;
+        ready = false;
+        sock.addEventListener("open", () => {
+            backoff = 500;
+            void auth();
+        });
+        sock.addEventListener("message", (e) => {
+            let m;
+            try {
+                m = JSON.parse(String(e.data));
+            }
+            catch {
+                return;
+            }
+            if (m.t === "ready") {
+                ready = true;
+                if (wantJoin)
+                    sock.send(JSON.stringify({ t: "join", ...(state !== undefined ? { state } : {}) }));
+            }
+            else if (m.t === "joined") {
+                me = m.self;
+                members.clear();
+                for (const x of m.members)
+                    members.set(x.id, x);
+                joining?.resolve({ self: me, members: [...members.values()] });
+                joining = null;
+                emitPresence({ event: "sync" });
+                while (queue.length)
+                    sock.send(queue.shift());
+            }
+            else if (m.t === "presence") {
+                const mem = m.member;
+                if (m.event === "leave")
+                    members.delete(mem.id);
+                else
+                    members.set(mem.id, mem);
+                emitPresence({ event: m.event, member: mem });
+            }
+            else if (m.t === "message") {
+                for (const f of handlers.get(m.event) ?? [])
+                    f(m.data, m.from);
+            }
+            else if (m.t === "error") {
+                if (m.code === "unauthenticated" && me)
+                    void auth();
+                else
+                    fail(new ChannelError(m.code ?? "internal", m.message ?? "channel error"));
+            }
+        });
+        sock.addEventListener("close", () => {
+            ws = null;
+            ready = false;
+            me = null;
+            if (left || !wantJoin)
+                return;
+            // Others see us leave; we'll join again and see a fresh member list.
+            setTimeout(open, backoff);
+            backoff = Math.min(backoff * 2, 30_000);
+        });
+    }
+    return {
+        name,
+        join(s) {
+            if (s !== undefined)
+                state = s;
+            wantJoin = true;
+            left = false;
+            return new Promise((resolve, reject) => {
+                joining = { resolve, reject };
+                if (ws && ready)
+                    ws.send(JSON.stringify({ t: "join", ...(state !== undefined ? { state } : {}) }));
+                else
+                    open();
+            });
+        },
+        setState(s) {
+            state = s;
+            raw({ t: "state", state: s });
+        },
+        broadcast(event, data) {
+            raw({ t: "broadcast", event, data: data ?? null });
+        },
+        send(to, event, data) {
+            raw({ t: "broadcast", event, data: data ?? null, to });
+        },
+        on(event, fn) {
+            if (!handlers.has(event))
+                handlers.set(event, new Set());
+            handlers.get(event).add(fn);
+            return () => void handlers.get(event)?.delete(fn);
+        },
+        onPresence(fn) {
+            presence.add(fn);
+            return () => void presence.delete(fn);
+        },
+        onError(fn) {
+            errors.add(fn);
+            return () => void errors.delete(fn);
+        },
+        members: () => [...members.values()],
+        self: () => me,
+        leave() {
+            left = true;
+            wantJoin = false;
+            queue.length = 0;
+            members.clear();
+            me = null;
+            ws?.close(1000, "left");
+            ws = null;
+        },
+    };
+}

package/dist/compat/app.d.ts

@@ -0,0 +1,33 @@
+import { type EstraAuth } from "../auth.js";
+import { type Transport } from "../transport.js";
+export interface FirebaseOptions {
+    /** The Estra server (required here; Firebase's own keys are accepted and ignored). */
+    estraUrl?: string;
+    apiKey?: string;
+    authDomain?: string;
+    projectId?: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    appId?: string;
+    /** Tests / non-browser runtimes: the fetch and WebSocket to use. */
+    estraFetch?: typeof fetch;
+    estraWebSocket?: typeof WebSocket;
+    [key: string]: unknown;
+}
+export interface FirebaseApp {
+    readonly name: string;
+    readonly options: FirebaseOptions;
+    readonly automaticDataCollectionEnabled: boolean;
+    /** Estra internals shared by getAuth / getFirestore. */
+    readonly _estra: {
+        url: string;
+        auth: EstraAuth;
+        transport: Transport;
+    };
+}
+export declare function initializeApp(options: FirebaseOptions, name?: string | {
+    name?: string;
+}): FirebaseApp;
+export declare const getApps: () => FirebaseApp[];
+export declare function getApp(name?: string): FirebaseApp;
+export declare function deleteApp(app: FirebaseApp): Promise<void>;

package/dist/compat/app.js

@@ -0,0 +1,37 @@
+// Firebase-compatible `firebase/app` for apps moving to Estra by import swap (a bundler alias of
+// firebase/app → @estra/client/compat/app, and likewise auth, firestore, storage). One app holds
+// the Estra URL, the signed-in session and the transport, so getAuth(app) and getFirestore(app)
+// share the user's token, as Firebase's do.
+//
+//   initializeApp({ estraUrl: "https://api.example.com", ...the old firebaseConfig })
+//
+// The transport is offline() over HTTP with the in-memory store: latency compensation and
+// hasPendingWrites as with Firestore's default memory cache.
+import { createAuth } from "../auth.js";
+import { offline } from "../offline.js";
+import { EstraClientError, httpTransport } from "../transport.js";
+const DEFAULT = "[DEFAULT]";
+const apps = new Map();
+export function initializeApp(options, name = DEFAULT) {
+    const n = typeof name === "string" ? name : (name.name ?? DEFAULT);
+    if (apps.has(n))
+        throw new EstraClientError("app/duplicate-app", `Firebase App named '${n}' already exists`);
+    const url = options.estraUrl;
+    if (!url)
+        throw new EstraClientError("app/invalid-app-argument", "initializeApp needs estraUrl (the Estra server URL)");
+    const f = options.estraFetch;
+    const auth = createAuth({ url, ...(f ? { fetch: f } : {}) });
+    const transport = offline(httpTransport({ url, getToken: () => auth.getIdToken(), ...(f ? { fetch: f } : {}), ...(options.estraWebSocket ? { WebSocket: options.estraWebSocket } : {}) }));
+    const app = { name: n, options, automaticDataCollectionEnabled: false, _estra: { url, auth, transport } };
+    apps.set(n, app);
+    return app;
+}
+export const getApps = () => [...apps.values()];
+export function getApp(name = DEFAULT) {
+    return apps.get(name) ?? (() => {
+        throw new EstraClientError("app/no-app", `No Firebase App '${name}' has been created - call initializeApp() first`);
+    })();
+}
+export async function deleteApp(app) {
+    apps.delete(app.name);
+}

package/dist/compat/auth.d.ts

@@ -0,0 +1,141 @@
+import type { AuthUser, EstraAuth } from "../auth.js";
+import { type FirebaseApp } from "./app.js";
+export type Unsubscribe = () => void;
+/** Firebase's error shape: `name: "FirebaseError"`, `code: "auth/…"`. */
+export declare class FirebaseError extends Error {
+    readonly code: string;
+    readonly customData?: Record<string, unknown>;
+    constructor(code: string, message: string);
+}
+export interface UserInfo {
+    readonly uid: string;
+    readonly providerId: string;
+    readonly email: string | null;
+    readonly displayName: string | null;
+    readonly photoURL: string | null;
+    readonly phoneNumber: string | null;
+}
+export declare class User implements UserInfo {
+    #private;
+    readonly providerId = "firebase";
+    readonly phoneNumber: null;
+    readonly tenantId: null;
+    constructor(auth: Auth, u: AuthUser);
+    get uid(): string;
+    get email(): string | null;
+    get emailVerified(): boolean;
+    get displayName(): string | null;
+    get photoURL(): string | null;
+    get isAnonymous(): boolean;
+    get providerData(): UserInfo[];
+    get metadata(): {
+        creationTime: string;
+        lastSignInTime: string | undefined;
+    };
+    /** @internal */ _update(u: AuthUser): void;
+    getIdToken(forceRefresh?: boolean): Promise<string>;
+    getIdTokenResult(forceRefresh?: boolean): Promise<{
+        token: string;
+        claims: Record<string, unknown>;
+        authTime: string;
+        issuedAtTime: string;
+        expirationTime: string;
+        signInProvider: null;
+        signInSecondFactor: null;
+    }>;
+    reload(): Promise<void>;
+    delete(): Promise<void>;
+    toJSON(): {
+        uid: string;
+        email: string | null;
+        emailVerified: boolean;
+        displayName: string | null;
+        photoURL: string | null;
+        isAnonymous: boolean;
+    };
+}
+export interface UserCredential {
+    user: User;
+    providerId: string | null;
+    operationType: "signIn" | "link" | "reauthenticate";
+    /** @internal */ _isNewUser: boolean;
+}
+export declare class Auth {
+    #private;
+    readonly app: FirebaseApp;
+    readonly name: string;
+    readonly _estra: EstraAuth;
+    languageCode: string | null;
+    constructor(app: FirebaseApp);
+    get currentUser(): User | null;
+    /** @internal */ _wrap(u: AuthUser | null): User | null;
+    authStateReady(): Promise<void>;
+    onAuthStateChanged(next: (u: User | null) => void): Unsubscribe;
+    signOut(): Promise<void>;
+}
+export declare function getAuth(app?: FirebaseApp): Auth;
+export declare const initializeAuth: (app: FirebaseApp, _deps?: unknown) => Auth;
+export declare const browserLocalPersistence: {
+    readonly type: "LOCAL";
+};
+export declare const browserSessionPersistence: {
+    readonly type: "SESSION";
+};
+export declare const inMemoryPersistence: {
+    readonly type: "NONE";
+};
+export declare const indexedDBLocalPersistence: {
+    readonly type: "LOCAL";
+};
+export declare const setPersistence: (_auth: Auth, _p: unknown) => Promise<void>;
+export declare function onAuthStateChanged(auth: Auth, next: ((u: User | null) => void) | {
+    next?: (u: User | null) => void;
+}, _error?: (e: Error) => void): Unsubscribe;
+export declare const onIdTokenChanged: typeof onAuthStateChanged;
+export declare const beforeAuthStateChanged: (_auth: Auth, _cb: unknown) => Unsubscribe;
+export declare const signInWithEmailAndPassword: (auth: Auth, email: string, password: string) => Promise<UserCredential>;
+export declare const createUserWithEmailAndPassword: (auth: Auth, email: string, password: string) => Promise<UserCredential>;
+export declare const signInAnonymously: (auth: Auth) => Promise<UserCredential>;
+export declare const signOut: (auth: Auth) => Promise<void>;
+export declare const sendPasswordResetEmail: (auth: Auth, email: string, _settings?: unknown) => Promise<undefined>;
+export declare const confirmPasswordReset: (auth: Auth, oobCode: string, newPassword: string) => Promise<undefined>;
+export declare const sendSignInLinkToEmail: (auth: Auth, email: string, _settings?: unknown) => Promise<undefined>;
+export declare const signInWithEmailLink: (auth: Auth, _email: string, link: string) => Promise<UserCredential>;
+export declare const isSignInWithEmailLink: (_auth: Auth, link: string) => boolean;
+export declare const sendEmailVerification: (user: User, _settings?: unknown) => Promise<undefined>;
+export declare const applyActionCode: (auth: Auth, oobCode: string) => Promise<void>;
+export declare const updateProfile: (user: User, p: {
+    displayName?: string | null;
+    photoURL?: string | null;
+}) => Promise<void>;
+export declare const updatePassword: (user: User, newPassword: string) => Promise<undefined>;
+export declare const deleteUser: (user: User) => Promise<void>;
+type Pid = "google.com" | "apple.com" | "github.com";
+declare class ProviderBase {
+    readonly providerId: Pid;
+    constructor(id: Pid);
+    addScope(_s: string): this;
+    setCustomParameters(_p: Record<string, string>): this;
+}
+export declare class GoogleAuthProvider extends ProviderBase {
+    static readonly PROVIDER_ID = "google.com";
+    constructor();
+}
+export declare class GithubAuthProvider extends ProviderBase {
+    static readonly PROVIDER_ID = "github.com";
+    constructor();
+}
+export declare class OAuthProvider extends ProviderBase {
+    constructor(id: string);
+}
+export declare const signInWithPopup: (auth: Auth, provider: ProviderBase, _resolver?: unknown) => Promise<UserCredential>;
+export declare const linkWithPopup: (user: User, provider: ProviderBase) => Promise<UserCredential>;
+export declare const reauthenticateWithPopup: (user: User, provider: ProviderBase) => Promise<UserCredential>;
+export declare const signInWithRedirect: (auth: Auth, provider: ProviderBase) => Promise<void>;
+export declare const getRedirectResult: (auth: Auth) => Promise<UserCredential | null>;
+export declare function getAdditionalUserInfo(cred: UserCredential): {
+    isNewUser: boolean;
+    providerId: string | null;
+    profile: Record<string, unknown> | null;
+} | null;
+export {};