palbase 0.8.1 → 0.9.1

package/types/server/src/webhooks.d.ts

@@ -37,7 +37,7 @@ export declare const DEFAULT_MAX_WEBHOOK_BYTES: number;
  * The event, once its signature and time are checked; a WebhookSignatureError
  * otherwise. A PalbaseEvent: a switch on its type narrows its data to what
  * that type's contract says. An event of a type no contract declares — one a
- * newer platform sends, or one whose module declares none yet (user.deleted)
+ * newer platform sends, or one whose module declares none yet (secret.changed)
  * — is none of the switch's cases at run time and reaches its default: take
  * it there (a 2xx), never throw, or the platform delivers it again and again.
  * verifyWebhook<T>() reads such an event's data as T.

package/types/web/src/analytics.d.ts

@@ -1,5 +1,22 @@
 import type { Transport } from '../../internal/src/transport.js';
+import type { Consent } from './consent.js';
+import { type Installation } from './installation.js';
 import type { SessionManager } from './session.js';
+/**
+ * What is known of the person: the signed-in user, or with no one signed in
+ * this browser's anonymous id — whose properties become the user's once they
+ * sign in. Kept with the analytics key: nothing is sent while it is not granted.
+ */
+export interface People {
+    /** Sets each property, replacing what was set. */
+    set(properties: Record<string, unknown>): Promise<void>;
+    /** Sets each property not set already: where the person first came from. */
+    setOnce(properties: Record<string, unknown>): Promise<void>;
+    /** Removes these properties. */
+    unset(keys: readonly string[]): Promise<void>;
+    /** Adds each number to what the property holds (none is 0). */
+    add(numbers: Record<string, number>): Promise<void>;
+}
 export interface AnalyticsOptions {
     /** A $pageview for the first page and each navigation after it (history and back/forward). Default true. */
     pageViews?: boolean;
@@ -18,33 +35,55 @@ export interface AnalyticsTiming {
     now?: () => number;
 }
 export declare class Analytics {
+    /** The person's events, identify and properties: what says who they are. */
     private readonly api;
     private readonly closingApi;
+    /** Timings: who they are of goes with them only while analytics is allowed — the user's token included. */
+    private readonly perfApi;
+    private readonly closingPerfApi;
     private readonly flushMs;
     private readonly flushAt;
     private readonly now;
     private readonly anonKey;
     private readonly sessionKey;
+    private readonly onceKey;
     private events;
     private samples;
     private timer;
     private memoryAnon;
     private memorySession;
+    /** What captureOnce sent in the session it names. */
+    private memoryOnce;
     private appVersion;
     private stopAuto;
     private readonly session;
+    private readonly consent;
     /** Someone signed in: their identify goes with the next send, never on the sign-in itself. */
     private identifyPending;
-    constructor(transport: Transport, session: SessionManager, origin: string, timing?: AnalyticsTiming);
+    private readonly listeners;
+    /** The person's properties. */
+    readonly people: People;
+    /**
+     * transport sends with the signed-in user's token; keyOnly with the
+     * publishable key alone — what goes while analytics is not allowed.
+     */
+    constructor(transport: Transport, keyOnly: Transport, session: SessionManager, consent: Consent, installation: Installation, origin: string, timing?: AnalyticsTiming);
     /** Records an event: a name (a letter or $, then letters, digits and _.:-$; 64 at most) and its properties. */
     capture(event: string, properties?: Record<string, unknown>): void;
+    private readOnce;
+    private writeOnce;
+    /**
+     * Told of each event the app captures, here on the device, whatever the person chose of analytics: what an in-app
+     * message's trigger is matched with. Nothing leaves the device for it. Returns what stops it.
+     */
+    onEvent(listener: (event: string, properties?: Record<string, unknown>) => void): () => void;
     /**
      * Records a page view: the page's address (the current one unless given),
      * its title, where the visitor came from. What the SDK reads on its own
-     * goes without query and fragment — the page's address, and the browser's
-     * document.referrer, which on a same-site arrival is the whole previous URL
-     * (a reset link's token, a sign-in callback's code). What the app passes
-     * is sent as it passed it.
+     * goes as its route (routeOf): no query, no fragment, no id or token in its
+     * path — the page's address, and the browser's document.referrer, which on
+     * a same-site arrival is the whole previous URL (a reset link's token, a
+     * sign-in callback's code). What the app passes is sent as it passed it.
      */
     page(page?: {
         url?: string;
@@ -68,6 +107,8 @@ export declare class Analytics {
      * request timings (each on unless turned off). Returns what stops them.
      */
     start(opts?: AnalyticsOptions): () => void;
+    private granted;
+    private person;
     private hold;
     private sample;
     private soon;
@@ -85,3 +126,13 @@ export declare class Analytics {
  * caused by input. Returns what stops the observers (and reports what stands).
  */
 export declare function observeWebVitals(record: (name: 'LCP' | 'CLS' | 'INP' | 'FCP' | 'TTFB', value: number) => void): () => void;
+/**
+ * A path as its route — what is kept, not what is struck out. A segment
+ * stays only when it reads as a word of the route: lowercase after its
+ * first letter, two digits at most ("v1", "oauth2"), each part between - and
+ * _ sixteen letters at most; it is kept lowercased, as the module keeps it.
+ * Anything else — a number, an id, an email, a token, an encoded value — is
+ * :id, and a segment's parameters (;token=…) go. A short lowercase word that
+ * is in fact a secret reads as a route's: secrets stay out of paths.
+ */
+export declare function routeOf(path: string): string;

package/types/web/src/client.d.ts

@@ -4,8 +4,12 @@ import { type RetryPolicy } from '../../internal/src/retry.js';
 import { type RefreshMode, type SessionStore } from './session.js';
 import { RealtimeSocket } from './socket.js';
 import { Analytics, type AnalyticsOptions } from './analytics.js';
+import { Consent, type ConsentOptions } from './consent.js';
+import { Installation } from './installation.js';
+import { Notify } from './notify.js';
 import { Purchases } from './purchases.js';
 import { type ChatToolCall } from './chat.js';
+import { Flags } from './flags.js';
 export interface ClientOptions {
     /** The project's address: https://<ref>.<domain> */
     url: string;
@@ -30,13 +34,23 @@ export interface ClientOptions {
     /**
      * Starts what the browser tells of itself, as the app's analytics: page
      * views, web vitals and request timings (true for all of them, or say which).
-     * Off unless given; events the app captures (`analytics.capture`) go either way.
+     * Off unless given; events the app captures (`analytics.capture`) go either
+     * way — each only while its consent key is granted (`consent`).
      */
     analytics?: boolean | AnalyticsOptions;
+    /**
+     * What the person allowed, as the app starts it: each key's starting value
+     * until the person chooses (`start: { analytics: 'granted', performance:
+     * 'denied' }` — where the law asks first, denied), the version of the
+     * consent text the app shows, and the app's own keys. Analytics collects
+     * nothing for a key with neither a starting value nor a choice. The
+     * person's choices are pb.consent's (set, needsAsking, onChange).
+     */
+    consent?: ConsentOptions;
     /**
      * The app's version, as its users see it ("2.4.1"): said with a paywall's
-     * request, for a placement's targeting rules that read it. Nothing is said
-     * without one.
+     * request and a flags read, for a placement's targeting rules and a flag's
+     * conditions that read it. Nothing is said without one.
      */
     appVersion?: string;
     /**
@@ -67,10 +81,18 @@ export interface PalbaseClient {
     socket: RealtimeSocket;
     /** The transport every module call goes through (credentials, refresh, retries). */
     transport: Transport;
-    /** The app's analytics: events it captures, page views, and — once started — the browser's own measures. */
+    /** The app's analytics: events it captures, the person's properties, page views, and — once started — the browser's own measures. */
     analytics: Analytics;
+    /** What the person allowed, key by key: their choices, kept here and sent to the project, the keys a screen lists, the keys to ask about. */
+    consent: Consent;
+    /** This browser's install of the app, as the project knows it: its installation id. */
+    installation: Installation;
     /** What the signed-in customer has (live, onCustomerInfo), the paywall's catalog, and buying on the web. */
     purchases: Purchases;
+    /** The project's notifications as this app takes them: this browser's pushes (Web Push). */
+    notify: Notify;
+    /** The project's feature flags and remote configuration, resolved for this app and its reader, kept current as they change. */
+    flags: Flags;
     /** The language every request says from now on (ClientOptions.language); null for the browser's own. */
     setLanguage(language: string | readonly string[] | null): void;
     /**

package/types/web/src/consent.d.ts

@@ -0,0 +1,218 @@
+import { auth as authModule } from '../../internal/src/modules/index.js';
+import { type Installation } from './installation.js';
+import { type SessionManager } from './session.js';
+import type { RealtimeSocket } from './socket.js';
+type Api = ReturnType<typeof authModule.client>;
+/** A key's state, as the person chose it or the app starts it. */
+export type ConsentState = 'granted' | 'denied';
+/** Where the person is, as far as a consent screen cares: gdpr asks before anything is collected, us collects until refused. */
+export type ConsentRegion = authModule.ConsentRegion;
+/** Told each key whose state changed: the person's choice, a refusal from the project, a sign-in or sign-out. */
+export type ConsentListener = (key: string, state: ConsentState | undefined) => void;
+/** A key a consent screen lists. */
+export interface ConsentKeyInfo {
+    key: string;
+    /** What it is about; custom is the app's own key. */
+    category: authModule.ConsentKey['category'] | 'custom';
+    /** Its words by language (en, tr); the app's own keys have none — the app words them. */
+    title: Record<string, string>;
+    description: Record<string, string>;
+    /** What the US laws call selling or sharing: Global Privacy Control refuses it, and a refusal is not asked again for twelve months. */
+    ads: boolean;
+}
+export interface ConsentOptions {
+    /**
+     * What the app starts with, key by key, until the person chooses — what is
+     * collected before anyone was asked. Where the law asks first (the EU, the
+     * UK: region() says) a key starts denied. A key the SDK collects for with
+     * no starting value and no choice collects nothing: give `analytics`
+     * (events, page views, person properties) and `performance` (web vitals,
+     * request timings) when the app uses them. Starting values never leave the
+     * browser: only the person's own choices are sent.
+     */
+    start?: Readonly<Record<string, ConsentState>>;
+    /**
+     * The version of the consent text the app shows ("2026-10"): sent with
+     * each choice made under it, and a choice made under another is to be
+     * asked again (needsAsking).
+     */
+    textVersion?: string;
+    /** The app's own keys, custom.<name> (a-z, 0-9 and _, 48 at most): listed by keys() after the platform's. */
+    customKeys?: readonly string[];
+}
+export interface ConsentDeps {
+    /** The module's calls as this user — their token, or no call at all: never another user's who signed in meanwhile. */
+    userApi: (user: string) => Api;
+    /** The same with the publishable key alone: the device's own choices. */
+    deviceApi: Api;
+    session: SessionManager;
+    socket: RealtimeSocket;
+    ref: string;
+    installation: Installation;
+    origin: string;
+    options?: ConsentOptions;
+    now?: () => number;
+}
+export declare class Consent {
+    private readonly userApi;
+    private readonly deviceApi;
+    private readonly session;
+    private readonly socket;
+    private readonly ref;
+    private readonly installation;
+    private readonly start;
+    private readonly textVersion;
+    private readonly customKeys;
+    private readonly storeKey;
+    private readonly now;
+    private kept;
+    private listeners;
+    /** The app uses consent: the person's account is followed, and what is unsent is sent. */
+    private engaged;
+    private platformKeys;
+    private watch;
+    private sending;
+    private sendAgain;
+    private retryTimer;
+    private retries;
+    /** Whose choices the project last answered in this page (a user's id, null for the device's); undefined: none yet. */
+    private readFor;
+    /** A refused choice stands denied here because its re-read failed: the project's state is read with the next attempt. */
+    private stale;
+    /** This page's last write stamp. */
+    private lastW;
+    /** This page's last choice time. */
+    private lastChosen;
+    /** The browser's Global Privacy Control, as the page was loaded with it. */
+    private readonly gpc;
+    constructor(deps: ConsentDeps);
+    /**
+     * The keys a consent screen lists: the platform's, in the order a screen
+     * shows them, with their words — read from the project once — then the
+     * app's own (customKeys).
+     */
+    keys(): Promise<ConsentKeyInfo[]>;
+    /**
+     * The key's state: the person's choice, else the app's starting value;
+     * undefined when there is neither. Denied while what was kept is not known
+     * (unreadable, or the project refused it) until the project's answer is taken.
+     */
+    state(key: string): ConsentState | undefined;
+    /**
+     * The project's state is still to be read: what is kept is not known
+     * (unreadable, a refused link), stands denied only for want of its answer
+     * (a refused choice), or is someone else's.
+     */
+    private owesRead;
+    /** Who the choices here are of now: the signed-in user, or this install. */
+    private holder;
+    /** When the key was last refused — here, on another of the person's devices, or by the project on their word. */
+    lastDeniedAt(key: string): Date | undefined;
+    /** Records the person's choice of one key: it stands at once and is sent to the project. */
+    set(key: string, state: ConsentState): void;
+    /** Records the person's choices of several keys, made together (one consent screen). */
+    setMany(choices: Readonly<Record<string, ConsentState>>): void;
+    /** Listens to every key whose state changes; returns the unsubscribe. */
+    onChange(listener: ConsentListener): () => void;
+    /** Where the person is, as the project tells from their address: what the app's starting values follow. */
+    region(): Promise<ConsentRegion>;
+    /**
+     * The keys of `keys` (every key, unless given) the app is to ask the
+     * person about: those never chosen, and those chosen on the app's screen
+     * under another textVersion than the app's — but in the US not an ads key
+     * the person refused within twelve months (CCPA §1798.135(c)(4)).
+     */
+    needsAsking(keys?: readonly string[]): Promise<string[]>;
+    private engage;
+    private subject;
+    private secret;
+    private platform;
+    private read;
+    /**
+     * The project's answer of whose choices: the browser takes it — but a
+     * choice made here and not yet sent is newer than any answer, and stands.
+     * An answer for someone other than who is signed in now is dropped.
+     * recorded: choices the answer is the project's record of (just sent):
+     * their copies here give way to it, at whatever time the project kept them
+     * (a device clock ahead of the project's is not later).
+     */
+    private adopt;
+    /**
+     * The project refused a choice sent: nothing it did not record may stand
+     * here. Its state is read again and taken; when that fails too, the keys go
+     * denied — never the refused grant — and are read again with the next attempt.
+     */
+    private refused;
+    /**
+     * A choice made here: it stands now, and goes after the ones before it —
+     * an older one is not dropped for it: refused, the newer one leaves the
+     * older standing.
+     */
+    private queue;
+    /** Sends what is not sent yet: one run at a time; a change meanwhile is sent after it. */
+    private send;
+    /** Sends what is unsent of the device and of who is signed in; false when it could not be sent now. */
+    private sendUnsent;
+    /** Sends whose unsent choices (a user's, or null: the device's); true when any went. */
+    private sendOf;
+    /** The next call's choices: whose, made the same way (source, text version), fifty at most. */
+    private nextGroup;
+    private retryLater;
+    private signedIn;
+    /**
+     * Signed out: the device goes back to the app's starting values — every
+     * key it holds a choice of is unset, as the device's — and the next person
+     * here is asked anew. A choice the signed-out person made that has not
+     * been sent waits for them.
+     */
+    private signedOut;
+    private follow;
+    private unfollow;
+    private held;
+    /**
+     * A change told: read at once — not after a read still on its way, which
+     * may be slow: answers can come in any order, a key's older one never
+     * replaces its newer. A read that fails is made again with the next attempt.
+     */
+    private changed;
+    /**
+     * While the browser sends Global Privacy Control, an ads key stands denied
+     * for the person here — unless they granted it in the app after this
+     * browser recorded GPC's refusal for them: a choice they make after it is
+     * theirs. A reset, another tab's, a sign-in does not undo it.
+     */
+    private gpcRefuses;
+    /**
+     * GPC's refusal goes to the project (source gpc) for every ads key it
+     * refuses here: once per person, and again whenever what stands for them
+     * is not a refusal (a reset, another tab's, came after it).
+     */
+    private refuseByGpc;
+    private states;
+    private tell;
+    /** What the store holds: the choices; empty — never written, or cleared; or unreadable — what it holds is not choices. */
+    private load;
+    /**
+     * Another tab wrote the choices: they stand here too, with what this page
+     * has not sent yet. Cleared or unreadable there, this page's choices stand
+     * — a refusal is never undone by a read that came back empty — and are
+     * written back.
+     */
+    private reload;
+    /**
+     * Writes what this page holds merged with what another tab wrote meanwhile
+     * — a key's later write stands, whichever tab made it — and tells what the
+     * merge changed here.
+     */
+    private commit;
+    private write;
+    /**
+     * When a choice is made: now, but later than this page's last — two
+     * choices of a page never share a time (a reset, and the Global Privacy
+     * Control refusal after it, are one after the other, not a tie).
+     */
+    private chosenAt;
+    /** The next mark stamp: later than any this browser wrote that this page has seen. */
+    private stamp;
+}
+export {};

package/types/web/src/flags.d.ts

@@ -0,0 +1,75 @@
+import { flags as flagsModule } from '../../internal/src/modules/index.js';
+import { type Transport } from '../../internal/src/transport.js';
+import { type Installation } from './installation.js';
+import type { SessionManager } from './session.js';
+import type { RealtimeSocket } from './socket.js';
+/** What reports an experiment's exposure once a session: the client's analytics (its captureOnce is internal, so not named by type here). */
+interface ExposureSink {
+    captureOnce(key: string, event: string, properties: Record<string, unknown>): void;
+}
+/** Where a value came from: the flag, the user's own, or an experiment's variant. */
+export type FlagSource = 'system' | 'override' | 'experiment';
+/** Told the keys whose values changed. */
+export type FlagsListener = (keys: string[]) => void;
+/** The project's flags as this reader sees them. */
+export declare class Flags {
+    /** Every client operation of the flags contract, through the session's transport. */
+    readonly api: ReturnType<typeof flagsModule.client>;
+    private session;
+    private socket;
+    private installation;
+    private ref;
+    private analytics;
+    /** The app's version, when it gave one: what a condition on versions reads. */
+    private appVersion;
+    private storageKey;
+    private held;
+    private listeners;
+    private started;
+    private leave;
+    /** The read running, and one asked for while it runs: read after it, once however often it was asked. */
+    private running;
+    private queued;
+    /** A reader just came (or the page opened): their first read is a snapshot, asked with the ETag of what is held. */
+    private fresh;
+    constructor(transport: Transport, session: SessionManager, socket: RealtimeSocket, installation: Installation, ref: string, origin: string, analytics: ExposureSink, appVersion?: string);
+    /** A flag's value, any JSON; undefined when there is none (yet). */
+    value(key: string): unknown;
+    /** A bool flag's value, or fallback when there is none or it is not a bool. */
+    bool(key: string, fallback: boolean): boolean;
+    /** A string flag's value, or fallback. */
+    string(key: string, fallback: string): string;
+    /** A number flag's value, or fallback. */
+    number(key: string, fallback: number): number;
+    /** An object flag's value, as the app's own type (not checked), or fallback. */
+    json<T>(key: string, fallback: T): T;
+    /** Every flag's value by key. Reading them here reports no experiment's reading: read a flag by its key for that. */
+    all(): Record<string, unknown>;
+    /** Where a value came from. */
+    source(key: string): FlagSource | undefined;
+    /** The version the values held are current as of. */
+    get version(): string | undefined;
+    /**
+     * Listens to the values: told the keys that changed — a change on the server, the values read for another reader
+     * (the last one's go first). The first listener starts keeping the values current. Returns what stops it.
+     */
+    onChange(listener: FlagsListener): () => void;
+    /**
+     * Brings the values up to date now: what changed since the version held, or a snapshot when there is none or the
+     * delta no longer reaches. The first call (or the first read, or listener) also starts keeping them current.
+     */
+    refresh(): Promise<void>;
+    /** The values held, when they are this reader's: read without waiting, and with no network, for another's never. */
+    private mine;
+    private start;
+    private follow;
+    private join;
+    private changed;
+    private read;
+    private fetch;
+    /** What the reads say of the app: the web, its version, and this install — proven with its secret while no one is signed in, whom audiences and experiments then ask about. */
+    private headers;
+    private apply;
+    private tell;
+}
+export {};

package/types/web/src/inapp.d.ts

@@ -0,0 +1,129 @@
+import { type Transport } from '../../internal/src/transport.js';
+import { type Installation } from './installation.js';
+import type { SessionManager } from './session.js';
+import type { Purchases } from './purchases.js';
+import { type MessageCloseReason } from './message/present.js';
+import type { MessageHandlers } from './screen/render.js';
+import type { Appearance } from './screen/resolve.js';
+/** What an offer's button is taken with when the app does not take it: the customer's purchases (pb.purchases). */
+type OfferTaker = Pick<Purchases, 'offers' | 'claimOffer' | 'checkout'>;
+/** The event a session's start is, as a campaign's trigger names it. */
+export declare const SESSION_START = "session_start";
+export interface InAppOptions {
+    /** The browser's language unless given. */
+    locale?: string;
+    /** The system's unless given. */
+    appearance?: Appearance;
+    /** The element messages are shown in: the page's body unless given. */
+    root?: HTMLElement;
+    /** A link of the app's a button opens (deep_link); without it the page goes to it. */
+    onDeepLink?(link: string): void;
+    /** An https address a button opens; without it the browser opens it in a new tab. */
+    onLink?(url: string): void;
+    /** The app's own code a button names. */
+    onCustom?(name: string, value?: string): void;
+    /** The paywall of a placement a button shows; without it its button is not drawn. */
+    onShowPaywall?(placement: string): void | Promise<void>;
+    /**
+     * One of the catalog's offers a button takes (offer), unless the SDK takes it: a grant claimed, else Stripe
+     * Checkout of its first web plan with the offer, back to this page.
+     */
+    onOffer?(offer: string): void | Promise<void>;
+    /** An offer the SDK could not take (no one signed in, a guest, the offer no longer theirs, the network). Without one it is thrown, and the message stays. */
+    onOfferError?(error: unknown, offer: string): void;
+    /** The push ask's button: the browser's prompt and this browser subscribed (pb.notify.push.subscribe), unless the app does it. */
+    onRequestPush?(): void | Promise<void>;
+    /** Told as a campaign shows, and as it closes. */
+    onShow?(campaignId: string): void;
+    onClose?(campaignId: string, reason: MessageCloseReason): void;
+    labels?: MessageHandlers['labels'];
+}
+type Globals = {
+    document?: Document;
+    location?: {
+        href: string;
+        assign(url: string): void;
+    };
+    navigator?: {
+        language?: string;
+    };
+    matchMedia?: (q: string) => MediaQueryList;
+    localStorage?: Storage;
+};
+/** The project's in-app campaigns, shown in this page. */
+export declare class InApp {
+    private api;
+    private session;
+    private installation;
+    private g;
+    private now;
+    private requestPush;
+    private analyticsAllowed;
+    private purchases;
+    /** Each load's turn: an answer for whoever was here before is not kept. */
+    private asked;
+    /** Whose the page's campaigns are: one more as someone else comes. */
+    private person;
+    private sessionKey;
+    private pendingKey;
+    private opts;
+    private messages;
+    private limits;
+    private shown;
+    private loaded;
+    private memorySession;
+    private memoryPending;
+    private showing;
+    private stopWatching;
+    /** Events are taken one after another: an event's show is asked before the next one is looked at. */
+    private queue;
+    constructor(transport: Transport, session: SessionManager, installation: Installation, origin: string, requestPush: () => Promise<unknown>, analyticsAllowed: () => boolean, purchases: OfferTaker, g?: Globals, now?: () => number);
+    /** Whether it was started: campaigns are shown only then. */
+    get started(): boolean;
+    /**
+     * Starts showing the person's campaigns in this page: asked for now (a session's start shows those it triggers),
+     * and again as each session starts. Once is enough; again changes the options.
+     */
+    start(opts?: InAppOptions): void;
+    /** Stops showing campaigns: one on screen closes. */
+    stop(): void;
+    /** The person's campaigns asked for again (they are as each session starts). */
+    refresh(): Promise<void>;
+    /**
+     * An event of the app's, as a campaign's trigger names it: shows the first campaign it triggers that its caps
+     * let, and counts a conversion of one shown that it is. Events the app captures come here by themselves.
+     */
+    trigger(event: string, properties?: Record<string, unknown>): void;
+    /** Waits for the events given so far to be taken (a test's, an app's before it navigates). */
+    settled(): Promise<void>;
+    private enqueue;
+    private take;
+    private show;
+    /** Whether a campaign showing now would pass a cap, as far as this page knows: the server's answer is the word. */
+    private capped;
+    /** Asks the server to show a campaign and, shown, shows it: false when a cap of the person's other devices held it. */
+    private open;
+    /**
+     * An offer's button as the SDK takes it: the customer's offer of that key — a grant claimed; a discount or a trial
+     * bought with, on its first web plan, through Stripe Checkout, which comes back to this page. One that is not
+     * theirs to take on the web is refused here (offer_not_open), as the module refuses it. What could not be taken
+     * is the app's to hear when it listens; thrown otherwise.
+     */
+    private takeOffer;
+    /** Reports the conversions an event is: of campaigns shown to whoever is here now, within their hours. */
+    private converted;
+    private forget;
+    private load;
+    /** Whose the page's campaigns are: the person signed in, or this browser's install. */
+    private subject;
+    private appearance;
+    /** Marks the session in use now: true when a new one starts (the first, or one after half an hour away). */
+    private touch;
+    private sessionId;
+    private readSession;
+    private writeSession;
+    private pending;
+    private keepPending;
+    private pend;
+}
+export {};

package/types/web/src/inbox.d.ts

@@ -0,0 +1,59 @@
+import { notify as notifyModule } from '../../internal/src/modules/index.js';
+import type { Transport } from '../../internal/src/transport.js';
+import type { SessionManager } from './session.js';
+import type { Appearance } from './screen/resolve.js';
+export type InboxItem = notifyModule.InboxItem;
+export type InboxPage = notifyModule.InboxPage;
+export interface InboxListOptions {
+    /** 1 to 500; the server's page unless given. */
+    limit?: number;
+    /** The previous page's next_cursor. */
+    cursor?: string;
+    /** The language to write it in: the one the person chose unless given. */
+    locale?: string;
+}
+export interface InboxViewOptions {
+    /** The language to write it in: the one the person chose unless given; a card's words in the browser's. */
+    locale?: string;
+    /** The system's unless given. */
+    appearance?: Appearance;
+    /** How many it shows: 50 unless given. */
+    limit?: number;
+    /** A message's link, as a tap opens it: an https address in a new tab and an app's link in this page unless given. */
+    onOpen?(item: InboxItem, link: string): void;
+    /** A designed card's own buttons. */
+    onCustom?(name: string, value?: string): void;
+    /** Told of the count of unread messages as it changes: what a badge shows. */
+    onUnread?(count: number): void;
+    /** Its words: an empty inbox, a delete button's name. */
+    labels?: {
+        empty?: string;
+        delete?: string;
+    };
+}
+export interface InboxView {
+    /** Asks for the inbox again and draws it. */
+    refresh(): Promise<void>;
+    /** The messages drawn now. */
+    readonly items: readonly InboxItem[];
+    /** How many of the whole inbox are unread. */
+    readonly unread: number;
+    /** Removes it from the page. */
+    destroy(): void;
+}
+/** The signed-in person's inbox. */
+export declare class Inbox {
+    private api;
+    private session;
+    constructor(transport: Transport, session: SessionManager);
+    /** A page of the inbox, newest first, with how many of it all are unread. Someone signed in only. */
+    list(opts?: InboxListOptions): Promise<InboxPage>;
+    /** How many messages are unread. */
+    unread(): Promise<number>;
+    /** Marks messages read — some by id, or all — on every device of the person's: how many became read. */
+    markRead(ids: readonly string[] | 'all'): Promise<number>;
+    /** Deletes a message, from every device of the person's. */
+    remove(id: string): Promise<void>;
+    /** Draws the inbox into a container: a ready list, kept current. */
+    mount(container: HTMLElement, opts?: InboxViewOptions): InboxView;
+}