@comfyorg/account-core 1.0.0-alpha.0

package/dist/core/sessionState.js

@@ -0,0 +1,235 @@
+import { isPermanentSessionError } from './sessionContracts.js';
+export function initialSessionState() {
+    return {
+        user: null,
+        identitySettled: false,
+        credential: undefined,
+        credentialTarget: undefined,
+        failure: undefined,
+        committedMint: undefined,
+        identityEpoch: 0,
+        invalidationEpoch: 0,
+        mintSequence: 0
+    };
+}
+const clearStorage = { type: 'clearStorage' };
+const stopScheduler = { type: 'stopScheduler' };
+const abandonInFlight = { type: 'abandonInFlight' };
+const publish = { type: 'publish' };
+function dropSession(state) {
+    return {
+        ...state,
+        credential: undefined,
+        credentialTarget: undefined,
+        failure: undefined
+    };
+}
+function applyIdentityChanged(state, event) {
+    return {
+        state: {
+            ...dropSession(state),
+            user: event.user,
+            identitySettled: true,
+            identityEpoch: state.identityEpoch + 1
+        },
+        // A sign-out or a different user makes the running mint unjoinable: it
+        // was started with the previous identity's token, and a caller arriving
+        // after the event must mint for itself. A same-uid re-auth must not
+        // adopt it either.
+        effects: event.user === null
+            ? [stopScheduler, abandonInFlight, clearStorage, publish]
+            : [stopScheduler, abandonInFlight, publish]
+    };
+}
+function applyIdentityDetached(state) {
+    return {
+        state: {
+            ...dropSession(state),
+            user: null,
+            identitySettled: false,
+            identityEpoch: state.identityEpoch + 1
+        },
+        effects: [stopScheduler, publish]
+    };
+}
+function applyInvalidated(state) {
+    // A mint still running belongs to the scope being discarded; a caller
+    // arriving after this must start its own rather than join it.
+    return {
+        state: {
+            ...dropSession(state),
+            invalidationEpoch: state.invalidationEpoch + 1
+        },
+        effects: [stopScheduler, abandonInFlight, clearStorage, publish]
+    };
+}
+function applyMintStarted(state) {
+    return {
+        state: { ...state, mintSequence: state.mintSequence + 1 },
+        effects: []
+    };
+}
+function applyMintCommitted(state, event) {
+    const target = event.origin === 'caller' ? event.target : state.credentialTarget;
+    const persist = {
+        type: 'persist',
+        session: event.session,
+        target
+    };
+    return {
+        state: {
+            ...state,
+            credential: event.session,
+            credentialTarget: target,
+            committedMint: { mintId: event.mintId, session: event.session },
+            failure: undefined
+        },
+        effects: event.origin === 'caller'
+            ? [persist, { type: 'armScheduler', session: event.session }, publish]
+            : [persist, publish]
+    };
+}
+function applySchedulerRejection(state, failure) {
+    return {
+        state: { ...dropSession(state), failure },
+        effects: [clearStorage, publish]
+    };
+}
+function applyCallerRejection(state, event) {
+    const permanent = isPermanentSessionError(event.failure.code);
+    if (!permanent &&
+        event.preserveCredentialOnTransientFailure &&
+        state.credential !== undefined) {
+        return { state, effects: [] };
+    }
+    if (!permanent) {
+        return {
+            state: { ...state, credential: undefined, failure: event.failure },
+            effects: [publish]
+        };
+    }
+    // A caller-initiated permanent failure must retire the armed scheduler
+    // and target too, or its old timer could resurrect the dead session.
+    return {
+        state: { ...dropSession(state), failure: event.failure },
+        effects: [stopScheduler, clearStorage, publish]
+    };
+}
+function applyMintRejected(state, event) {
+    return event.origin === 'scheduler'
+        ? applySchedulerRejection(state, event.failure)
+        : applyCallerRejection(state, event);
+}
+function applyCredentialAdopted(state, event) {
+    // Adoption is a commit: it supersedes any in-flight mint of this
+    // tab's own, exactly like a newer mint would.
+    return {
+        state: {
+            ...state,
+            mintSequence: state.mintSequence + 1,
+            credential: event.session,
+            failure: undefined
+        },
+        effects: [
+            {
+                type: 'persist',
+                session: event.session,
+                target: state.credentialTarget
+            },
+            publish
+        ]
+    };
+}
+function applyCredentialExpired(state, event) {
+    if (state.credential !== event.expiring)
+        return { state, effects: [] };
+    return {
+        state: {
+            ...dropSession(state),
+            failure: { status: 'error', code: 'TOKEN_EXCHANGE_FAILED' }
+        },
+        effects: [clearStorage, publish]
+    };
+}
+export function transition(state, event) {
+    switch (event.type) {
+        case 'identity-changed':
+            return applyIdentityChanged(state, event);
+        case 'identity-detached':
+            return applyIdentityDetached(state);
+        case 'invalidated':
+            return applyInvalidated(state);
+        case 'mint-started':
+            return applyMintStarted(state);
+        case 'mint-committed':
+            return applyMintCommitted(state, event);
+        case 'mint-rejected':
+            return applyMintRejected(state, event);
+        case 'credential-adopted':
+            return applyCredentialAdopted(state, event);
+        case 'credential-expired':
+            return applyCredentialExpired(state, event);
+    }
+}
+const SUPERSEDED = { verdict: 'superseded' };
+function supersededByInvalidation(state, attempt) {
+    return state.invalidationEpoch !== attempt.startInvalidation;
+}
+// The newest mint won, but when it committed a credential for this
+// caller's exact target, that credential answers the request — a lost
+// race is not a failure. A different target (or none) stays undefined.
+function lostRace(state, attempt) {
+    if (attempt.mintId === state.mintSequence)
+        return undefined;
+    const answered = state.credential !== undefined &&
+        state.credential.uid === attempt.userUid &&
+        state.user?.uid === attempt.userUid &&
+        attempt.requestedTarget === state.credentialTarget;
+    return answered ? { verdict: 'reuse', session: state.credential } : SUPERSEDED;
+}
+function crossedIdentityEvent(state, attempt) {
+    return state.identityEpoch !== attempt.startEpoch;
+}
+// The one mint allowed to cross an identity event: an explicit-user
+// mint started while signed out, for the user the port then
+// delivered (the popup path) as the single event since. Everything else
+// was minted for an identity that is gone, even when the uid matches again.
+function popupSettled(state, attempt) {
+    return (attempt.explicitUser &&
+        attempt.startedSignedOut &&
+        state.identityEpoch === attempt.startEpoch + 1 &&
+        state.user?.uid === attempt.userUid);
+}
+// The explicit-user bypass is the popup path, valid only before the
+// identity port has ever fired; a settled null identity blocks it.
+function userMismatchBlocksCommit(state, attempt) {
+    return (state.user?.uid !== attempt.userUid &&
+        (!attempt.explicitUser || state.user !== null || state.identitySettled));
+}
+function joinerReuse(state, attempt) {
+    return attempt.joined &&
+        state.committedMint !== undefined &&
+        state.committedMint.mintId === attempt.mintId &&
+        state.credential === state.committedMint.session
+        ? { verdict: 'reuse', session: state.committedMint.session }
+        : undefined;
+}
+export function arbitrateMint(state, attempt) {
+    if (supersededByInvalidation(state, attempt))
+        return SUPERSEDED;
+    const raced = lostRace(state, attempt);
+    if (raced)
+        return raced;
+    const stale = crossedIdentityEvent(state, attempt)
+        ? !popupSettled(state, attempt)
+        : userMismatchBlocksCommit(state, attempt);
+    if (stale)
+        return SUPERSEDED;
+    return joinerReuse(state, attempt) ?? { verdict: 'commit' };
+}
+export function scheduledMintHolds(state, guards, userUid, mintId) {
+    return (mintId === state.mintSequence &&
+        state.user?.uid === userUid &&
+        state.identityEpoch === guards.epoch &&
+        state.invalidationEpoch === guards.invalidation);
+}

package/dist/firebase/index.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The package-owned identity entry. Hosts either pass Firebase configuration
+ * — including the persistence choice — for an app the package initializes,
+ * or hand over the `Auth` they already hold, and get back the identity
+ * surface the session core binds to plus the sign-in actions.
+ *
+ * Popup, never `signInWithRedirect`: the redirect flow is broken under
+ * Safari's ITP for cross-origin helper domains, which is why the cloud app
+ * is popup-only too. Provider scopes and the `select_account` prompt are the
+ * cloud app's.
+ *
+ * This entry is the one place the package touches the Firebase SDK;
+ * importGuard.test.ts holds `./core` to that boundary.
+ */
+import type { FirebaseOptions } from 'firebase/app';
+import type { Auth, Persistence, User, UserCredential } from 'firebase/auth';
+import type { AccountIdentity } from '../core/identity.js';
+export interface FirebaseIdentityAppConfig {
+    readonly options: FirebaseOptions;
+    /** Named app: never contend with a default app another script creates. */
+    readonly appName?: string;
+    /** Host-selected persistence; Firebase's default when omitted. */
+    readonly persistence?: Persistence;
+    /** A host-owned `Auth` and package-owned app options are exclusive. */
+    readonly auth?: never;
+}
+/**
+ * A host that already holds an `Auth` (the cloud app's vuefire instance)
+ * binds the entry to it: no second app, no second persistence store.
+ */
+export interface FirebaseIdentityAuthConfig {
+    readonly auth: Auth;
+    readonly options?: never;
+    readonly appName?: never;
+    readonly persistence?: never;
+}
+export type FirebaseIdentityConfig = FirebaseIdentityAppConfig | FirebaseIdentityAuthConfig;
+export interface FirebaseIdentity extends AccountIdentity<User> {
+    /**
+     * Fires with the restored user (or null) once Firebase settles, then on
+     * every change. This is the identity the session core binds to.
+     */
+    onUserChanged: (callback: (user: User | null) => void) => () => void;
+    signInWithGoogle: () => Promise<UserCredential>;
+    signInWithGitHub: () => Promise<UserCredential>;
+    signInWithEmail: (email: string, password: string) => Promise<UserCredential>;
+    createUserWithEmail: (email: string, password: string) => Promise<UserCredential>;
+    sendPasswordReset: (email: string) => Promise<void>;
+    /** For the signed-in user; rejects when nobody is signed in. */
+    updatePassword: (newPassword: string) => Promise<void>;
+    signOut: () => Promise<void>;
+}
+export declare function createFirebaseIdentity(config: FirebaseIdentityConfig): FirebaseIdentity;

package/dist/firebase/index.js

@@ -0,0 +1,74 @@
+import { getApps, initializeApp } from 'firebase/app';
+import { GithubAuthProvider, GoogleAuthProvider, createUserWithEmailAndPassword, getAuth, initializeAuth, onAuthStateChanged, sendPasswordResetEmail, signInWithEmailAndPassword, signInWithPopup, signOut, updatePassword } from 'firebase/auth';
+import { identityBrand } from '../core/identity.js';
+import { isFirebaseAuthErrorLike } from '../firebaseAuthError.js';
+function googleProvider() {
+    const provider = new GoogleAuthProvider();
+    provider.addScope('email');
+    provider.setCustomParameters({ prompt: 'select_account' });
+    return provider;
+}
+function githubProvider() {
+    const provider = new GithubAuthProvider();
+    provider.addScope('user:email');
+    provider.setCustomParameters({ prompt: 'select_account' });
+    return provider;
+}
+/**
+ * An unknown email must look exactly like a sent reset, which is how Firebase
+ * itself answers with email enumeration protection on; a distinct failure
+ * here would be an account enumeration oracle.
+ */
+function resolveUnknownEmailAsSent(error) {
+    if (isFirebaseAuthErrorLike(error) && error.code === 'auth/user-not-found') {
+        return;
+    }
+    throw error;
+}
+/**
+ * Resolved once per identity. A named app this entry creates gets the
+ * host's persistence through `initializeAuth`; an app another entry already
+ * created keeps the persistence its creator chose, since Firebase allows one
+ * Auth per app.
+ */
+function authResolver(config) {
+    if (config.auth) {
+        const { auth } = config;
+        return () => auth;
+    }
+    const appName = config.appName ?? 'comfy-account';
+    let resolved;
+    return () => {
+        if (resolved)
+            return resolved;
+        const existing = getApps().find((app) => app.name === appName);
+        if (existing) {
+            resolved = getAuth(existing);
+            return resolved;
+        }
+        const app = initializeApp(config.options, appName);
+        resolved = config.persistence
+            ? initializeAuth(app, { persistence: config.persistence })
+            : getAuth(app);
+        return resolved;
+    };
+}
+export function createFirebaseIdentity(config) {
+    const auth = authResolver(config);
+    return {
+        [identityBrand]: true,
+        onUserChanged: (callback) => onAuthStateChanged(auth(), callback),
+        signInWithGoogle: () => signInWithPopup(auth(), googleProvider()),
+        signInWithGitHub: () => signInWithPopup(auth(), githubProvider()),
+        signInWithEmail: (email, password) => signInWithEmailAndPassword(auth(), email, password),
+        createUserWithEmail: (email, password) => createUserWithEmailAndPassword(auth(), email, password),
+        sendPasswordReset: (email) => sendPasswordResetEmail(auth(), email).catch(resolveUnknownEmailAsSent),
+        updatePassword: (newPassword) => {
+            const user = auth().currentUser;
+            return user
+                ? updatePassword(user, newPassword)
+                : Promise.reject(new Error('No signed-in user to update the password for'));
+        },
+        signOut: () => signOut(auth())
+    };
+}

package/dist/firebaseAuthError.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Classification of Firebase Auth failures, shared so both hosts branch on
+ * the same buckets. Typed structurally rather than via `instanceof
+ * FirebaseError` so this package needs no firebase dependency — a host passes
+ * whatever it caught and unknown shapes land in 'unknown'.
+ */
+export interface FirebaseAuthErrorLike {
+    code: string;
+    message: string;
+}
+export type AuthErrorClassification = {
+    kind: 'unauthorized-domain';
+    code: string;
+} | {
+    kind: 'signup-blocked';
+    code: string;
+} | {
+    kind: 'popup-dismissed';
+    code: string;
+} | {
+    kind: 'auth';
+    code: string;
+} | {
+    kind: 'unknown';
+};
+export declare function isFirebaseAuthErrorLike(error: unknown): error is FirebaseAuthErrorLike;
+export declare function classifyAuthError(error: unknown): AuthErrorClassification;
+export type AuthToastSeverity = 'error' | 'warn';
+/**
+ * The cloud app's toast-severity policy for classified auth failures: a
+ * dismissed popup is the user changing their mind, not an application
+ * error; everything else alarms.
+ */
+export declare function severityForAuthError(classification: AuthErrorClassification): AuthToastSeverity;
+/**
+ * A host's auth error table: Firebase codes mapped to that host's copy, plus
+ * the two fallbacks every table must carry. Hosts build this from their own
+ * i18n; the package ships no strings of its own.
+ */
+export type AuthErrorCopy = Readonly<Record<string, string>> & {
+    readonly generic: string;
+    readonly signupBlocked: string;
+};
+/**
+ * The detail copy for a classified failure, resolved against the host copy:
+ * a code the table knows gets its own line, anything else the generic line, a
+ * blocked sign-up its named copy. The user-not-found / wrong-password pair
+ * collapses to the invalid-credential line so a sign-in attempt can never
+ * reveal whether an email has an account. Unauthorized domains need the
+ * host's domain and support address, which the host interpolates itself.
+ */
+export declare function authErrorMessage(classification: AuthErrorClassification, copy: AuthErrorCopy): string;

package/dist/firebaseAuthError.js

@@ -0,0 +1,88 @@
+/**
+ * Classification of Firebase Auth failures, shared so both hosts branch on
+ * the same buckets. Typed structurally rather than via `instanceof
+ * FirebaseError` so this package needs no firebase dependency — a host passes
+ * whatever it caught and unknown shapes land in 'unknown'.
+ */
+/**
+ * The user or their browser dismissed/blocked the popup — an outcome to warn
+ * about and retry on a fresh gesture, never an app fault.
+ */
+const POPUP_DISMISSED_CODES = [
+    'auth/popup-closed-by-user',
+    'auth/cancelled-popup-request',
+    'auth/popup-blocked'
+];
+/**
+ * The origin is not on the Firebase authorized-domains list (or a continue
+ * URI is unauthorized): auth cannot work here at all until configuration
+ * changes, so the host should say so rather than offer a retry.
+ */
+const UNAUTHORIZED_DOMAIN_CODES = [
+    'auth/unauthorized-domain',
+    'auth/invalid-dynamic-link-domain',
+    'auth/unauthorized-continue-uri'
+];
+export function isFirebaseAuthErrorLike(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code.startsWith('auth/') &&
+        'message' in error &&
+        typeof error.message === 'string');
+}
+export function classifyAuthError(error) {
+    if (!isFirebaseAuthErrorLike(error))
+        return { kind: 'unknown' };
+    if (UNAUTHORIZED_DOMAIN_CODES.includes(error.code)) {
+        return { kind: 'unauthorized-domain', code: error.code };
+    }
+    // Match on `error.message`, not `error.code`: Firebase `beforeUserCreated`
+    // rejections collapse the thrown code into a generic `auth/internal-error`,
+    // so the message is the only reliable channel. `signup_blocked` is a
+    // cross-repo contract token; matched case-insensitively.
+    if (error.message.toLowerCase().includes('signup_blocked')) {
+        return { kind: 'signup-blocked', code: error.code };
+    }
+    if (POPUP_DISMISSED_CODES.includes(error.code)) {
+        return { kind: 'popup-dismissed', code: error.code };
+    }
+    return { kind: 'auth', code: error.code };
+}
+/**
+ * The cloud app's toast-severity policy for classified auth failures: a
+ * dismissed popup is the user changing their mind, not an application
+ * error; everything else alarms.
+ */
+export function severityForAuthError(classification) {
+    return classification.kind === 'popup-dismissed' ? 'warn' : 'error';
+}
+/** Resolved to the invalid-credential line whatever table is in play. */
+const ENUMERATION_NEUTRAL_CODES = new Set([
+    'auth/user-not-found',
+    'auth/wrong-password'
+]);
+/**
+ * The detail copy for a classified failure, resolved against the host copy:
+ * a code the table knows gets its own line, anything else the generic line, a
+ * blocked sign-up its named copy. The user-not-found / wrong-password pair
+ * collapses to the invalid-credential line so a sign-in attempt can never
+ * reveal whether an email has an account. Unauthorized domains need the
+ * host's domain and support address, which the host interpolates itself.
+ */
+export function authErrorMessage(classification, copy) {
+    switch (classification.kind) {
+        case 'signup-blocked':
+            return copy.signupBlocked;
+        case 'popup-dismissed':
+        case 'auth':
+            if (ENUMERATION_NEUTRAL_CODES.has(classification.code)) {
+                return copy['auth/invalid-credential'] ?? copy.generic;
+            }
+            return copy[classification.code] ?? copy.generic;
+        case 'unauthorized-domain':
+        case 'unknown':
+            return copy.generic;
+    }
+}

package/dist/loadExternalScript.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a singleton loader for an external script. `getReady` should return
+ * the resolved value when the script's global is available, or `null` when not.
+ * The returned function caches the in-flight Promise so concurrent callers share
+ * one load, and resets on failure so a later caller can retry.
+ */
+export declare function createScriptLoader<T>(src: string, getReady: () => T | null, timeoutMs?: number): () => Promise<T>;

package/dist/loadExternalScript.js

@@ -0,0 +1,88 @@
+/** Keep in sync with packages/shared-frontend-utils/src/loadExternalScript.ts. */
+const POLL_INTERVAL_MS = 50;
+/**
+ * Returns a singleton loader for an external script. `getReady` should return
+ * the resolved value when the script's global is available, or `null` when not.
+ * The returned function caches the in-flight Promise so concurrent callers share
+ * one load, and resets on failure so a later caller can retry.
+ */
+export function createScriptLoader(src, getReady, timeoutMs = 10_000) {
+    let scriptPromise = null;
+    return function loadScript() {
+        if (scriptPromise)
+            return scriptPromise;
+        scriptPromise = new Promise((resolve, reject) => {
+            let settled = false;
+            let cancelPoll;
+            function trySettle(fn) {
+                if (settled)
+                    return;
+                settled = true;
+                fn();
+            }
+            const ready = getReady();
+            if (ready !== null) {
+                resolve(ready);
+                return;
+            }
+            const existing = document.querySelector(`script[src="${src}"]`);
+            function startPoll(onSuccess) {
+                const pollId = window.setInterval(() => {
+                    const value = getReady();
+                    if (value !== null) {
+                        window.clearInterval(pollId);
+                        onSuccess();
+                        trySettle(() => resolve(value));
+                    }
+                }, POLL_INTERVAL_MS);
+                return () => window.clearInterval(pollId);
+            }
+            if (existing) {
+                // load/error may have already fired on the pre-existing tag; poll for readiness
+                const timeoutId = window.setTimeout(() => {
+                    cancelPoll?.();
+                    trySettle(() => {
+                        scriptPromise = null;
+                        reject(new Error(`Script load timed out: ${src}`));
+                    });
+                }, timeoutMs);
+                cancelPoll = startPoll(() => window.clearTimeout(timeoutId));
+                return;
+            }
+            const scriptEl = document.createElement('script');
+            const timeoutId = window.setTimeout(() => {
+                cancelPoll?.();
+                scriptEl.remove();
+                trySettle(() => {
+                    scriptPromise = null;
+                    reject(new Error(`Script load timed out: ${src}`));
+                });
+            }, timeoutMs);
+            scriptEl.addEventListener('load', () => {
+                if (settled)
+                    return;
+                const value = getReady();
+                if (value !== null) {
+                    window.clearTimeout(timeoutId);
+                    trySettle(() => resolve(value));
+                }
+                else {
+                    // global may arrive asynchronously after load; poll under the shared timeout
+                    cancelPoll = startPoll(() => window.clearTimeout(timeoutId));
+                }
+            }, { once: true });
+            scriptEl.addEventListener('error', () => {
+                window.clearTimeout(timeoutId);
+                scriptEl.remove();
+                trySettle(() => {
+                    scriptPromise = null;
+                    reject(new Error(`Script failed to load: ${src}`));
+                });
+            }, { once: true });
+            scriptEl.src = src;
+            scriptEl.async = true;
+            document.head.appendChild(scriptEl);
+        });
+        return scriptPromise;
+    };
+}

package/dist/provisioning.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The account-creation sequences both hosts must agree on, with the effects
+ * injected so the invariants live (and are tested) exactly once. Mirrors the
+ * platform app's `authStore.register` / `loginWithGoogle` semantics.
+ */
+interface DeletableUserCredential {
+    user: {
+        delete: () => Promise<void>;
+    };
+}
+/**
+ * Email sign-up: create the Firebase user, then provision the Comfy customer.
+ *
+ * Provisioning is where a Turnstile token gets validated server-side; if it
+ * fails (rejection, 5xx, network) the Firebase user is already created and,
+ * without rollback, the account is orphaned — every retry then fails
+ * "email already in use", permanently bricking signup. So a provisioning
+ * failure deletes the just-created user (best-effort with one retried
+ * delete, so a single transient blip cannot orphan the account; a cleanup
+ * failure never masks the original error) and rethrows.
+ */
+export declare function signUpWithProvisioning<T extends DeletableUserCredential>(deps: {
+    createUser: () => Promise<T>;
+    provisionCustomer: (credential: T) => Promise<unknown>;
+    onRollbackFailure?: (error: unknown) => void;
+}): Promise<T>;
+/**
+ * Social sign-in: the popup, then find-or-create the Comfy customer — always,
+ * because a social user's first touch may be this host and skipping the
+ * customer record produces accounts where billing surfaces fail.
+ * `provisionCustomer` must tolerate an already-provisioned account. No
+ * rollback here: the signed-in user may be a long-standing account, and
+ * deleting it over a provisioning hiccup would destroy it — a provisioning
+ * failure propagates with the user still signed in.
+ */
+export declare function socialSignInWithProvisioning<T>(deps: {
+    signIn: () => Promise<T>;
+    provisionCustomer: (credential: T) => Promise<unknown>;
+}): Promise<T>;
+export declare const CUSTOMER_PROVISIONING_PATH = "/customers";
+/**
+ * The `POST /customers` request both hosts send. `signupSource` names the
+ * host for the backend's attribution; the Turnstile token rides along only
+ * on email sign-up, where the server validates it. Body and headers only: a
+ * host that wants a bound passes its own `signal`.
+ */
+export declare function customerProvisioningRequest(options: {
+    authHeaders: Record<string, string>;
+    signupSource: string;
+    turnstileToken?: string;
+    signal?: AbortSignal;
+}): RequestInit;
+export {};