@everfur/sdk 0.12.1 → 0.14.0

package/dist/optInView.d-s-w4aGN3.d.ts

@@ -0,0 +1,441 @@
+import { E as EverfurError } from './EverfurError.d-8NHtlgzA.js';
+import { E as EverfurResult } from './EverfurResult.d-D_-254ZY.js';
+import { R as RequestFunnel } from './requestFunnel.d-D9edIEjZ.js';
+import { A as AuthContext } from './identity.d-BePPZ7Uv.js';
+import { P as PetRef, U as UserRef } from './ids.d-B2GAAifq.js';
+import { E as ErrorPolicyPort } from './ErrorPolicyPort.d-68yrE3BE.js';
+
+/** The marker a placeholder string carries, so a test (and a reviewer) can find every one. */
+declare const COPY_PLACEHOLDER_PREFIX = "[copy needed: ";
+declare const TEXTING_COPY: Readonly<{
+    loading: "Loading";
+    retry: "Try again";
+    signedOut: "Sign in required";
+    close: "Close";
+    phoneLabel: "Mobile number";
+    phoneHint: "We'll text a 6-digit code to confirm it's you.";
+    phoneInvalid: "That doesn't look like a valid number. Check it and the country, then try again.";
+    consentRequired: "Please agree to receive SMS messages to continue.";
+    sendCode: "Send code";
+    sendingCode: "Sending code";
+    codeTitle: "Enter your code";
+    /** Followed by the number, which is data, not copy. */
+    codeSentTo: "We texted a 6-digit code to";
+    codeLabel: "6-digit code";
+    codeInvalidFormat: "Enter all 6 digits of the code.";
+    confirmCode: "Verify";
+    confirmingCode: "Verifying";
+    verificationInvalid: "That code is no longer valid. Request a new one.";
+    /** everfur-frontend app/product/sms-chat/copy.ts:73, for a code refused after its `expires_at`. */
+    codeExpired: "This code has expired. Request a new one.";
+    requestNewCode: "Request a new code";
+    /** everfur-frontend app/product/sms-chat/copy.ts:74, for 429 `verification_phone_limit` (this number's daily codes). */
+    noResendsLeft: "You've requested the maximum number of codes. Please try again later or contact support.";
+    changeNumber: "Use a different number";
+    defaultPetLabel: "Default pet for SMS";
+    noPetSelected: "Choose a pet";
+    savePet: "Save";
+    savingPet: "Saving";
+    petSaved: "Saved";
+    petIneligible: "That pet can't be selected anymore. Please choose another.";
+    optedOutTitle: "SMS paused";
+    verifiedTitle: "SMS Chat is on";
+    disable: "Turn off SMS Chat";
+    disabling: "Turning off";
+    disableConfirmTitle: "Turn off SMS Chat?";
+    disableConfirmBody: "We'll stop texting this number. You can turn it back on anytime.";
+    disableConfirm: "Turn off";
+    disableCancel: "Keep it on";
+    unavailableTitle: "SMS Chat isn't available yet";
+    unavailableBody: "We're still setting it up. Check back soon.";
+    phoneAlreadyLinked: "This number is already linked to another Everfur account. Contact support and we'll move it for you.";
+    providerFailed: "We couldn't send the text. Please try again.";
+    genericFailure: "That didn't go through. Please try again.";
+    /** Followed by the request id, for a support conversation. */
+    supportReference: "Support reference:";
+    /**
+     * The ask (the in-chat line's two chips and the app-open pop-up, `EverfurTextingPrompt`): the consumer's invitation
+     * card (`promptBody` / `promptAccept` / `promptDismiss`, Aman 2026-09-15; everfur-mobile copy.ts:120-122). The
+     * in-chat line's chips are the same two words, as in both consumer apps.
+     */
+    promptBody: "Ask questions about your pet by text message, anytime. No app needed.";
+    promptAccept: "Turn on SMS Chat";
+    promptDismiss: "Not now";
+    /**
+     * 403 `phone_country_not_allowed`, a valid number from a country the tenant does not text. The consumer screen
+     * refuses a valid number whose own country is outside its list (everfur-frontend app/product/sms-chat/phone.ts:36)
+     * with this line (`phoneInvalid`, copy.ts:60, via SmsChatEnrollment.tsx:78-80), which points at the country.
+     */
+    phoneCountryNotAllowed: "That doesn't look like a valid number. Check it and the country, then try again.";
+    /**
+     * 429 `verification_tenant_limit`, the tenant's hourly ceiling on codes: not the member's doing, and it clears.
+     * everfur-frontend app/product/sms-chat/copy.ts:109 `temporarilyUnavailable` (everfur-mobile copy.ts:108).
+     */
+    verificationBusy: "SMS Chat is temporarily unavailable. Please try again in a few minutes.";
+    /**
+     * The label in front of the tenant profile's help contact, so the line reads "Help: hello@everfur.com" exactly as
+     * the owner-approved HELP reply does (EFBackend sms_chat_reply_copy.py:262 and :276, and the partner default
+     * partner_sms_profile.py:101).
+     */
+    helpContactLabel: "Help:";
+    /**
+     * The button that starts a new opt-in after a member opted out. The consumer's own "start SMS Chat" control:
+     * everfur-frontend copy.ts:118 `promptAccept`, the /sms page call to action (SmsOptInPage.tsx:75), everfur-mobile
+     * copy.ts:121.
+     */
+    reenroll: "Turn on SMS Chat";
+    /**
+     * The opted-out body for a member who turned texts off in the app (not by texting STOP, which keeps the brand STOP
+     * line). The consumer's approved words for that same choice: everfur-frontend copy.ts:98 `disableConfirmBody`
+     * (everfur-mobile copy.ts:102).
+     */
+    optedOutByMemberBody: "We'll stop texting this number. You can turn it back on anytime.";
+    codeWrong: "That code didn't work. Check it and try again.";
+}>;
+/** ADAPTED from the consumer deck: "Everfur" becomes the tenant's brand name. Listed for approval. */
+declare const TEXTING_BRAND_COPY: Readonly<{
+    /** consumer `introTitle`: 'Chat with Everfur by text' */
+    introTitle: (brand: string) => string;
+    /** consumer `introBody` */
+    introBody: (brand: string) => string;
+    /** consumer `statusActive`: 'You can text Everfur anytime from this number.' */
+    statusActive: (brand: string) => string;
+    /** consumer `optedOutBody` */
+    optedOutBody: (brand: string) => string;
+    /** consumer `promptTitle`: 'Ask Everfur by text, for every pet' (the app-open pop-up's title). */
+    promptTitle: (brand: string) => string;
+    /**
+     * consumer `chatAskLine`: 'Want answers by text too? Add your mobile number and you can text Everfur about your pet
+     * anytime.' (owner approved 2026-09-30; everfur-mobile copy.ts:128). The in-chat ask's line.
+     */
+    chatAskLine: (brand: string) => string;
+    /** consumer `statusUnrecorded`: "Verified. You're all set to text Everfur." The in-chat ask's closing line. */
+    chatAskVerified: (brand: string) => string;
+}>;
+/** Every placeholder key in `TEXTING_COPY`, so the list a reviewer approves cannot drift from the file. */
+declare const TEXTING_COPY_PLACEHOLDERS: readonly (keyof typeof TEXTING_COPY)[];
+/** Every string the texting opt-in shows that a partner may reword (`EverfurTextingOptIn copy=`). */
+type TextingCopy = {
+    readonly [K in keyof typeof TEXTING_COPY]: string;
+};
+/** The brand-named lines (`EverfurTextingOptIn brandCopy=`): each takes the tenant's brand name. */
+type TextingBrandCopy = {
+    readonly [K in keyof typeof TEXTING_BRAND_COPY]: (brand: string) => string;
+};
+
+/** The tenant's public texting profile, exactly as the console published it. */
+interface EverfurTextingProfile {
+    /** The name the texts, the consent words and the STOP/HELP replies use. */
+    readonly brandName: string;
+    /** The consent words the member ticks, verbatim. The server stores a digest of exactly these words. */
+    readonly consentText: string;
+    /** The version of `consentText`; sent back with the verification so the grant names what the member saw. */
+    readonly consentVersion: string;
+    /** Where a member gets help (a phone, an address or a URL as the tenant set it), or null. */
+    readonly helpContact: string | null;
+    /**
+     * EFBackend's `status_is_live`. There is no tester-only stage any more: a draft or live tenant admits every member,
+     * and only a tenant staff suspended refuses each number with `sms_not_live`, which the surface words as SMS Chat
+     * not being available. The surface draws no banner of its own for this flag.
+     */
+    readonly isLive: boolean;
+}
+/**
+ * Parse an untrusted `sms_profile_public` blob. Null when it is absent or carries no brand, consent words or
+ * consent version (the three things an opt-in cannot do without). `status_is_live` reads true only for the
+ * literal `true`: a missing flag is the not-live side, which refuses more, never less. Never throws.
+ */
+declare function parseTextingProfile(raw: unknown): EverfurTextingProfile | null;
+/**
+ * A +1 (United States or Canada) number as E.164, or null. Takes what a member types: `(415) 555-0134`,
+ * `415.555.0134`, `1 415 555 0134` or `+1 415 555 0134`. A North American number is ten digits whose area code and
+ * exchange both start 2 to 9; anything else (another country code, too few digits, letters) is null, so the
+ * surface refuses it before the wire instead of spending a verification on it.
+ */
+declare function toTextingE164(input: string): string | null;
+/** True for a string already in E.164 form (`+` and 8 to 15 digits). */
+declare function isE164(value: unknown): value is string;
+
+/** The identity states the server reports. An unknown value reads as `none`: nothing on record we can explain. */
+declare const EVERFUR_TEXTING_STATUSES: readonly ["none", "pending", "verified", "opted_out"];
+type EverfurTextingStatus = (typeof EVERFUR_TEXTING_STATUSES)[number];
+/** The member's texting identity. The raw number never comes back; `phoneMasked` is what Everfur shows anywhere. */
+interface EverfurTextingIdentity {
+    readonly status: EverfurTextingStatus;
+    readonly phoneMasked: string | null;
+    /** The consent version on record, or null. */
+    readonly consentVersion: string | null;
+    /** The pet texts are about, or null when none is chosen. */
+    readonly selectedPetRef: PetRef | null;
+}
+/** An outstanding code, as the server issued it. */
+interface EverfurTextingChallenge {
+    readonly challengeId: string;
+    /** ISO 8601, or null when the server did not say. */
+    readonly expiresAt: string | null;
+    /**
+     * How many wrong codes the server still accepts for this challenge, as it said when it issued the code
+     * (`attempts_remaining`), or null when it did not say. The controller counts it down on each refused code.
+     */
+    readonly attemptsRemaining: number | null;
+}
+interface EverfurTextingVerificationInput {
+    /** E.164 (`+14155550134`). `toTextingE164` turns what a member typed into this. */
+    readonly phoneE164: string;
+    /** The tenant profile's `consentVersion`: the words the member ticked. The server refuses any other. */
+    readonly consentVersion: string;
+}
+/** A code is digits only; the consumer screen asks for six. */
+declare const TEXTING_CODE_PATTERN: RegExp;
+interface TextingRepository {
+    /** `GET /widget/v1/me/sms-identity`. Settles; never throws. */
+    read(opts?: {
+        readonly signal?: AbortSignal;
+    }): Promise<EverfurResult<EverfurTextingIdentity>>;
+    /** `POST .../verification`: text a code to the number. Sent once, never replayed. */
+    startVerification(input: EverfurTextingVerificationInput): Promise<EverfurResult<EverfurTextingChallenge>>;
+    /** `POST .../verification/confirm`: spend the code. Sent once, never replayed. */
+    confirmVerification(challengeId: string, code: string): Promise<EverfurResult<EverfurTextingIdentity>>;
+    /** `PUT .../selected-pet`: the pet texts are about. */
+    selectPet(petRef: PetRef): Promise<EverfurResult<EverfurTextingIdentity>>;
+    /** `DELETE /widget/v1/me/sms-identity`: withdraw consent and stop texts. As available as opting in. */
+    optOut(): Promise<EverfurResult<EverfurTextingIdentity>>;
+}
+/** The part of the runtime this repository needs (`useEverfurContext().runtime` satisfies it). */
+interface TextingRuntime {
+    readonly isDisposed: boolean;
+    readonly registry: {
+        readonly services: {
+            authFor(userRef: UserRef | null): AuthContext;
+            readonly errorPolicy: ErrorPolicyPort | undefined;
+        };
+    };
+}
+/** The lower seam: one auth context, or an already-built funnel (tests). */
+interface TextingRepositoryDeps {
+    readonly auth: AuthContext;
+    readonly errorPolicy?: ErrorPolicyPort;
+    readonly funnel?: RequestFunnel;
+}
+/** The reason codes a surface branches on, by meaning. Read with `textingReasonOf`. */
+type EverfurTextingReason = 'not_live' | 'code_invalid' | 'phone_linked' | 'pet_ineligible' | 'no_identity' | 'consent_changed' | 'session_required' | 'country_not_allowed' | 'phone_code_limit' | 'tenant_code_limit';
+/** Which texting refusal an error is, or null for any other failure. */
+declare function textingReasonOf(error: EverfurError | null | undefined): EverfurTextingReason | null;
+/** The allowlist mapper for one identity body. `status` is REQUIRED: a body without one is not an identity. */
+declare function textingIdentityFromWire(raw: unknown): EverfurTextingIdentity | null;
+/** The repository over the runtime under your provider. Auth is read at CALL time; a disposed runtime sends nothing. */
+declare function createTextingRepository(runtime: TextingRuntime): TextingRepository;
+/** The same repository over one auth context (or an injected funnel). Internal seam, for deterministic tests. */
+declare function createTextingRepositoryOver(deps: TextingRepositoryDeps): TextingRepository;
+
+type TextingPhase = 'loading' | 'failed' | 'enroll' | 'requesting' | 'code' | 'confirming' | 'verified' | 'optingOut' | 'optedOut';
+/** What a refused code most likely was. See the header. */
+type TextingCodeRefusal = 'wrong' | 'expired' | 'spent';
+/** Which verb a refusal belongs to, so a surface retries the right thing. */
+type TextingAction = 'read' | 'start' | 'confirm' | 'selectPet' | 'optOut';
+interface TextingSnapshot {
+    readonly phase: TextingPhase;
+    /** The identity as the server last reported it, or null before the first read. */
+    readonly identity: EverfurTextingIdentity | null;
+    /** The outstanding code, while one is out. */
+    readonly challenge: EverfurTextingChallenge | null;
+    /** The number the current code went to (what the member typed, as E.164), for "request a new code". */
+    readonly phoneE164: string | null;
+    /** The last refusal, or null. `error.displayMessage` is safe to show. */
+    readonly error: EverfurError | null;
+    readonly failedAction: TextingAction | null;
+    /** For a refused code (`failedAction` 'confirm'), what it most likely was; null otherwise. */
+    readonly codeRefusal: TextingCodeRefusal | null;
+    /** True while a pet choice is being saved. */
+    readonly savingPet: boolean;
+    /**
+     * True while `requesting` is a new code for the code step ("Request a new code"), so a surface keeps the code step
+     * on screen with its link busy instead of flipping back to the number (audit 2026-10-20). False for a first send.
+     */
+    readonly resending: boolean;
+}
+declare class TextingController {
+    private readonly repository;
+    private readonly now;
+    private snapshot;
+    private readonly listeners;
+    /** Bumped by every step change; a settlement for an older generation is dropped. */
+    private generation;
+    private consentVersion;
+    private disposed;
+    /** `now` is the clock a refused code is judged against (epoch ms); tests pass their own. */
+    constructor(repository: TextingRepository, now?: () => number);
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly getSnapshot: () => TextingSnapshot;
+    private set;
+    /** Read the member's identity (the first load, and the way out of `failed`). */
+    load(): Promise<void>;
+    /** Text a code to `phoneE164` for the consent words of `consentVersion`. */
+    start(phoneE164: string, consentVersion: string): Promise<boolean>;
+    /** Text a new code to the same number. */
+    resend(): Promise<boolean>;
+    /** Check the code the member typed. */
+    confirm(code: string): Promise<boolean>;
+    /** Back to the number step ("use a different number"); any code in flight is abandoned. */
+    changeNumber(): void;
+    /** From `optedOut`, start a new opt-in. Withdrawing never locks a member out of coming back. */
+    reenroll(): void;
+    /** Choose the pet texts are about. The step does not change; only `savingPet` and the identity do. */
+    selectPet(petRef: PetRef): Promise<boolean>;
+    /** Withdraw consent and stop texts. */
+    optOut(): Promise<boolean>;
+    /** Stop notifying; any settlement after this is dropped. */
+    dispose(): void;
+}
+
+type EverfurTextingViewStatus = 'signedOut' | 'unavailable' | TextingSnapshot['phase'];
+interface EverfurTextingState {
+    readonly status: EverfurTextingViewStatus;
+    /** The tenant's public texting profile, or null when it has none. */
+    readonly profile: EverfurTextingProfile | null;
+    /** The controller's snapshot (identity, outstanding code, last refusal). */
+    readonly snapshot: TextingSnapshot;
+    /** Text a code to what the member typed. Refuses (settles false) for a number `validateTextingPhone` rejects. */
+    start(phone: string): Promise<boolean>;
+    resend(): Promise<boolean>;
+    confirm(code: string): Promise<boolean>;
+    changeNumber(): void;
+    reenroll(): void;
+    selectPet(petRef: PetRef): Promise<boolean>;
+    optOut(): Promise<boolean>;
+    /** Read the identity again (the way out of `failed`). */
+    refresh(): Promise<void>;
+}
+/** Why a member's input is not ready to send, or null when it is. */
+type EverfurTextingInputProblem = 'phoneInvalid' | 'consentRequired' | 'codeInvalidFormat';
+/** The opt-in's pre-flight: a +1 number and a ticked consent box, before any request is spent. */
+declare function validateTextingEnroll(phone: string, consented: boolean): EverfurTextingInputProblem | null;
+/** The surface asks for six digits, as the consumer screen does. */
+declare const TEXTING_UI_CODE_LENGTH = 6;
+declare function validateTextingCode(code: string): EverfurTextingInputProblem | null;
+/** The tenant's parsed texting profile, or null. Re-parses only when the verdict carries a new blob. */
+declare function useEverfurTextingProfile(): EverfurTextingProfile | null;
+/** The texting repository bound to the runtime under your provider, for a partner's own UI. */
+declare function useEverfurTextingRepository(): TextingRepository;
+/** The member's texting opt-in, step by step. `EverfurTextingOptIn` renders it on either host. */
+declare function useEverfurTexting(): EverfurTextingState;
+
+type TextingAskStage = 'hidden' | 'offered' | 'enrolling' | 'verified' | 'dismissed';
+interface TextingAskOptions {
+    /** The surface wants the ask (the chat's `chatTextingAsk`). Default true. */
+    readonly enabled?: boolean;
+    /** The surface is ready for it (the chat: an answer on screen, nothing in flight). Default true. */
+    readonly ready?: boolean;
+    /** Which surface draws it. A showing belongs to the surface that offered it; the other draws nothing. Default `prompt`. */
+    readonly surface?: 'chat' | 'prompt';
+}
+/** The ask's state and its answers. Every function is safe to call in any stage (a call out of turn does nothing). */
+interface TextingAsk {
+    readonly stage: TextingAskStage;
+    /** The tenant's brand name (its texting profile), for the brand-named lines. Empty while hidden. */
+    readonly brand: string;
+    /** Which ask this showing is (1, 2 or 3). */
+    readonly askNumber: 1 | 2 | 3;
+    /** The enrollment underneath (the opt-in's own state and steps). */
+    readonly texting: EverfurTextingState;
+    /** "Turn on SMS Chat": open the number entry. Answers nothing yet. */
+    accept(): void;
+    /** "Not now": one ask, unless this showing was already answered. The pop-up's close hands the ask to the chat. */
+    dismiss(): void;
+    /** The close control on the number entry: back to the two answers. Answers nothing. */
+    close(): void;
+    /** Text a code to what the member typed (a code request counts as accepting, once per showing). */
+    start(phone: string): Promise<boolean>;
+}
+/** The texting ask for the member under the provider. `EverfurChat` and `EverfurTextingPrompt` draw it. */
+declare function useTextingAsk(options?: TextingAskOptions): TextingAsk;
+
+/** What the member's identity read said: still unknown (loading, refused, not read), none yet, or one exists. */
+type TextingAskIdentity = 'unknown' | 'none' | 'exists';
+interface TextingAskDueInput {
+    /** The surface wants the ask: the chat's `chatTextingAsk`, true for the pop-up. */
+    readonly enabled: boolean;
+    readonly capabilityGranted: boolean;
+    readonly hasProfile: boolean;
+    readonly signedIn: boolean;
+    /** The schedule was readable and says this is an eligible ask. */
+    readonly scheduleEligible: boolean;
+    readonly offeredThisSession: boolean;
+    readonly identity: TextingAskIdentity;
+    /** The chat: a message on screen and nothing in flight. True for the pop-up. */
+    readonly surfaceReady: boolean;
+}
+interface TextingAskDue {
+    readonly readEnabled: boolean;
+    readonly due: boolean;
+}
+declare function resolveTextingAskDue(input: TextingAskDueInput): TextingAskDue;
+/** The parts of a chat message the thread rule reads (a `ChatMessage` is one). */
+interface TextingAskThreadMessage {
+    readonly role: string;
+    readonly text: string;
+    readonly pending?: boolean | undefined;
+    /** A platform check-in asks the member something; it is not an answer. */
+    readonly checkin?: unknown;
+    readonly urgencyLevel?: string | null | undefined;
+}
+/** The chat state the thread rule reads (`UseEverfurChatState` is one). */
+interface TextingAskThreadState {
+    readonly messages: ReadonlyArray<TextingAskThreadMessage>;
+    readonly status?: string | undefined;
+    readonly stopped?: boolean | undefined;
+    readonly isBootstrapping?: boolean | undefined;
+    readonly isLoadingHistory?: boolean | undefined;
+    readonly isStreaming?: boolean | undefined;
+}
+/**
+ * The chat's thread is ready for the ask: the line lands after an ANSWER (the consumer rule, everfur-mobile
+ * useSmsChatAsk.ts). Nothing is opening, loading or streaming, and the latest turn is a completed Everfur answer:
+ * the last row is the assistant's, settled and not empty, not a check-in, and not urgent (`URGENT_LEVELS`); the turn
+ * neither failed (the error card) nor was stopped. A vet's message is not Everfur's answer. This only gates the
+ * OFFER: a line already offered stays when a later turn fails (the ask's session entry holds it).
+ */
+declare function textingAskThreadReady(chat: TextingAskThreadState): boolean;
+
+/** The KvPort key (the web port adds its own `everfur:` namespace). */
+declare const TEXTING_ASK_SCHEDULE_KEY = "everfur.texting.askSchedule.v1";
+/** Flat snooze after every ask. Not a backoff. */
+declare const TEXTING_ASK_SNOOZE_MS: number;
+/** Lifetime cap on asks. */
+declare const TEXTING_ASK_MAX_ASKS = 3;
+/** One member's record. */
+interface TextingAskEntry {
+    readonly askCount: number;
+    /** Do not ask before this instant (epoch ms). Null when never asked. */
+    readonly nextAskAt: number | null;
+    readonly completed: boolean;
+}
+type TextingAskScheduleRead = {
+    readonly status: 'ok';
+    readonly entry: TextingAskEntry;
+} | {
+    readonly status: 'unreadable';
+};
+declare function isTextingAskEligible(read: TextingAskScheduleRead, now: number): boolean;
+
+/**
+ * The line for a refused step. The consumer deck's own words per refusal; never the raw server message. For a refused
+ * code, pass the snapshot's `codeRefusal` so a typo, an expired code and a used-up code read differently; without it
+ * (or when the controller could not tell) the line is the deck's generic "request a new one".
+ */
+declare function textingErrorText(error: EverfurError, action: TextingAction | null, codeRefusal?: TextingCodeRefusal | null, copy?: TextingCopy): string;
+/** The support line under a refusal, when the server named the request. Null otherwise. */
+declare function textingSupportText(error: EverfurError, copy?: TextingCopy): string | null;
+/** The line for input the surface refused before any request. */
+declare function textingInputProblemText(problem: EverfurTextingInputProblem, copy?: TextingCopy): string;
+/**
+ * The opted-out body: the brand STOP line for a member who texted STOP, the consumer's turn-off line for one who
+ * turned texts off in the app. The server tells them apart without a field of its own: an in-app turn-off revokes the
+ * identity, so `opted_out` comes back with no number (and the SDK's own turn-off settles to that shape), while a STOP
+ * keeps the live identity and its masked number (EFBackend partner_sms_identity.py `partner_status`).
+ */
+declare function textingOptedOutBody(identity: EverfurTextingIdentity | null, brand: string, copy?: TextingCopy, brandCopy?: TextingBrandCopy): string;
+/** A +1 E.164 number as a member reads it: `+14155550134` becomes `(415) 555-0134`. Anything else is unchanged. */
+declare function formatTextingPhone(e164: string | null): string;
+
+export { toTextingE164 as $, type TextingAskStage as A, type TextingAskThreadMessage as B, COPY_PLACEHOLDER_PREFIX as C, type TextingAskThreadState as D, type EverfurTextingViewStatus as E, type TextingCodeRefusal as F, TextingController as G, type TextingPhase as H, type TextingRepository as I, type TextingRepositoryDeps as J, type TextingRuntime as K, type TextingSnapshot as L, createTextingRepository as M, createTextingRepositoryOver as N, formatTextingPhone as O, isE164 as P, isTextingAskEligible as Q, parseTextingProfile as R, resolveTextingAskDue as S, type TextingCopy as T, textingAskThreadReady as U, textingErrorText as V, textingIdentityFromWire as W, textingInputProblemText as X, textingOptedOutBody as Y, textingReasonOf as Z, textingSupportText as _, type TextingBrandCopy as a, useEverfurTexting as a0, useEverfurTextingProfile as a1, useEverfurTextingRepository as a2, useTextingAsk as a3, validateTextingCode as a4, validateTextingEnroll as a5, type TextingAsk as b, EVERFUR_TEXTING_STATUSES as c, type EverfurTextingChallenge as d, type EverfurTextingIdentity as e, type EverfurTextingInputProblem as f, type EverfurTextingProfile as g, type EverfurTextingReason as h, type EverfurTextingState as i, type EverfurTextingStatus as j, type EverfurTextingVerificationInput as k, TEXTING_ASK_MAX_ASKS as l, TEXTING_ASK_SCHEDULE_KEY as m, TEXTING_ASK_SNOOZE_MS as n, TEXTING_BRAND_COPY as o, TEXTING_CODE_PATTERN as p, TEXTING_COPY as q, TEXTING_COPY_PLACEHOLDERS as r, TEXTING_UI_CODE_LENGTH as s, type TextingAction as t, type TextingAskDue as u, type TextingAskDueInput as v, type TextingAskEntry as w, type TextingAskIdentity as x, type TextingAskOptions as y, type TextingAskScheduleRead as z };

package/dist/parse.d-COt1qVA6.d.ts

@@ -0,0 +1,210 @@
+import { E as EverfurError } from './EverfurError.d-8NHtlgzA.js';
+import { E as EverfurResult } from './EverfurResult.d-D_-254ZY.js';
+import { E as ErrorPolicyPort } from './ErrorPolicyPort.d-68yrE3BE.js';
+import { A as AuthContext } from './identity.d-BePPZ7Uv.js';
+import { U as UserRef, R as RecordsRequestId, P as PetRef, C as ConversationId } from './ids.d-B2GAAifq.js';
+import { V as VetVisitIntent } from './visitIntent.d-D7_yVp1I.js';
+
+/** The push providers the registration route accepts. `apns` is refused with `provider_unsupported` until APNs direct lands. */
+type PushProvider = 'expo' | 'fcm' | 'apns';
+/** The device platforms the registration route accepts. There is no web push in this version. */
+type DevicePlatform = 'ios' | 'android';
+/** What to register: the token your notification library obtained, which provider minted it, and which OS it is for. */
+interface RegisterDeviceInput {
+    /**
+     * The push token as your library printed it: `ExponentPushToken[...]` from expo-notifications, or the FCM
+     * registration token from Firebase Messaging. Never an APNs device token in this version.
+     */
+    readonly token: string;
+    readonly provider: PushProvider;
+    readonly platform: DevicePlatform;
+    /** Your own stable id for this install, if you keep one (1 to 128 characters). Echoed back, never interpreted. */
+    readonly installationId?: string;
+}
+/** The device row as Everfur stored it. The token itself is never echoed. */
+interface RegisteredDevice {
+    /** Everfur's id for this device: pass it to `unregisterDevice` on sign-out. */
+    readonly deviceId: string;
+    readonly provider: PushProvider;
+    readonly platform: DevicePlatform;
+    readonly installationId: string | null;
+    /** ISO 8601. */
+    readonly registeredAt: string;
+    /** ISO 8601; refreshed by every registration of the same token. */
+    readonly lastSeenAt: string;
+}
+/** Both switches, always: the route is a replacement, not a patch. */
+interface NotificationPreferencesInput {
+    readonly pushEnabled: boolean;
+    readonly emailEnabled: boolean;
+}
+/** The member's switches as Everfur stored them. */
+interface NotificationPreferences {
+    readonly pushEnabled: boolean;
+    readonly emailEnabled: boolean;
+    /** ISO 8601. */
+    readonly updatedAt: string;
+}
+interface NotificationsClient {
+    /**
+     * `POST /widget/v1/me/devices`. Idempotent: the same token is the same device (its `lastSeenAt` moves), and a token
+     * another member of your tenant registered rebinds to the calling member. Settles `ok(RegisteredDevice)`;
+     * `validationFailed` with `reasonCode` `provider_unsupported` or `token_invalid`; `serviceUnavailable` with
+     * `reasonCode` `device_cipher_unavailable` (retry later); `rateLimited` above ten registrations a minute; the
+     * not-found error while notifications are not enabled for your tenant; `sessionRequired` for a publishable-key caller.
+     */
+    registerDevice(input: RegisterDeviceInput, opts?: {
+        readonly signal?: AbortSignal;
+    }): Promise<EverfurResult<RegisteredDevice>>;
+    /**
+     * `DELETE /widget/v1/me/devices/{device_id}`. Settles `ok(undefined)` on 204; an unknown id and another member's
+     * device are the same not-found error.
+     */
+    unregisterDevice(deviceId: string, opts?: {
+        readonly signal?: AbortSignal;
+    }): Promise<EverfurResult<void>>;
+    /** `PUT /widget/v1/me/notification-preferences`. Settles `ok(NotificationPreferences)`. */
+    setPreferences(input: NotificationPreferencesInput, opts?: {
+        readonly signal?: AbortSignal;
+    }): Promise<EverfurResult<NotificationPreferences>>;
+}
+/**
+ * The part of the runtime this client needs: the current auth at call time, the partner's error policy, and whether
+ * the runtime is gone. `useEverfurContext().runtime` (any `EverfurRuntime`) satisfies it; the narrow shape keeps this
+ * subpath's public types to what it reads.
+ */
+interface NotificationsRuntime {
+    readonly isDisposed: boolean;
+    readonly registry: {
+        readonly services: {
+            authFor(userRef: UserRef | null): AuthContext;
+            readonly errorPolicy: ErrorPolicyPort | undefined;
+        };
+    };
+}
+/** The sub-reasons a notifications call, or a delivery, can carry as `EverfurError.reasonCode`. */
+type NotificationsReasonCode = 'provider_unsupported' | 'token_invalid' | 'device_cipher_unavailable' | 'credentials_missing';
+/**
+ * DEVELOPER-FACING explanations, one per reason. Log them, show them on a developer screen, never render them to a
+ * member: `displayMessage` is the copy a person sees. `credentials_missing` is not a route answer but the reason a
+ * delivery is skipped on Everfur's side (visible on the events API and in the partner console); it is here so one
+ * table explains every reason this surface can name.
+ */
+declare const NOTIFICATIONS_REASON_MESSAGES: Readonly<Record<NotificationsReasonCode, string>>;
+/** The developer-facing sentence for an error's `reasonCode`, or null when it carries none this surface knows. */
+declare function explainNotificationsReason(error: EverfurError): string | null;
+/**
+ * The client over the runtime under your provider (`useEverfurContext().runtime`). Auth is read at call time, so the
+ * client can be built once and reused across sign-ins; a disposed runtime settles every verb without a request.
+ */
+declare function createNotificationsClient(runtime: NotificationsRuntime): NotificationsClient;
+
+/** What the hook needs from you: the token your notification library obtained, or null until you have one. */
+interface EverfurNotificationsOptions {
+    /**
+     * The push token as your library printed it (`ExponentPushToken[...]`, or an FCM registration token), or null
+     * while you do not have one (permission not asked, not granted, or the token not yet fetched). Nothing is
+     * registered without it; pass it as soon as you have it and the hook registers.
+     */
+    readonly token: string | null;
+    /** `expo` for a token from expo-notifications, `fcm` for a Firebase registration token. */
+    readonly provider: PushProvider;
+    readonly platform: DevicePlatform;
+    /** Your own stable id for this install, if you keep one. */
+    readonly installationId?: string;
+}
+/**
+ * `signed_out`: no signed-in user on the provider (nothing to register). `no_token`: a user, no token yet.
+ * `registering` / `registered` / `failed` / `unavailable`: the registration of the current token.
+ * `unavailable` is the dark tenant: notifications are not enabled for your client (the routes answer 404).
+ * `unregistered`: `unregister()` was called; `register()` registers again.
+ */
+type EverfurNotificationsStatus = 'signed_out' | 'no_token' | 'registering' | 'registered' | 'unavailable' | 'failed' | 'unregistered';
+interface EverfurNotificationsState {
+    readonly status: EverfurNotificationsStatus;
+    /** The device Everfur registered for this install and user, or null. */
+    readonly device: RegisteredDevice | null;
+    /** The settled failure of the last registration, or null. `error.displayMessage` is safe to show. */
+    readonly error: EverfurError | null;
+    /** Register the current token now (a retry after `failed`, or after `unregister()`). Settles, never throws. */
+    register(): Promise<EverfurResult<RegisteredDevice>>;
+    /** Unregister this install's device for the signed-in user. Settles, never throws. */
+    unregister(): Promise<EverfurResult<void>>;
+    /** The member's push and email switches, both at once (`PUT /widget/v1/me/notification-preferences`). */
+    setPreferences(input: NotificationPreferencesInput): Promise<EverfurResult<NotificationPreferences>>;
+}
+/**
+ * The notifications client bound to the runtime under your provider, for the imperative calls (`setPreferences`
+ * from a settings screen, say). Auth is read at call time, so one client serves every sign-in.
+ */
+declare function useEverfurNotificationsClient(): NotificationsClient;
+/**
+ * Register this install's push token for the signed-in member, keep it registered as the token and the user
+ * change, and unregister it before sign-out. Call it once, high in the tree under `EverfurProvider`.
+ */
+declare function useEverfurNotifications(options: EverfurNotificationsOptions): EverfurNotificationsState;
+
+/** The version of the routing block this release reads. */
+declare const EVERFUR_NOTIFICATION_VERSION = 1;
+/** The closed target kinds, in the backend's order (`partner_target.py` TARGET_KINDS). */
+declare const EVERFUR_NOTIFICATION_TARGET_KINDS: readonly ["record_request", "pet", "visit", "case"];
+/** One target kind. */
+type EverfurNotificationTargetKind = (typeof EVERFUR_NOTIFICATION_TARGET_KINDS)[number];
+/**
+ * The event types Everfur builds a push target for (`partner_target.py` TARGET_BUILDERS), in its order. The member
+ * events, the urgency verdict and the endpoint test event reach the partner's webhook only and never a device, and
+ * `visit.completed`, `visit.rescheduled` and `visit.ended` carry no consumer copy, so they are never pushed either;
+ * they are listed because the platform builds their target.
+ */
+declare const EVERFUR_NOTIFICATION_EVENT_TYPES: readonly ["record_request.updated", "record.ready", "pet.vaccination.due", "visit.booked", "visit.cancelled", "visit.completed", "visit.no_show", "visit.rescheduled", "visit.reminder", "visit.followup_sent", "visit.message_received", "visit.ended", "chat.follow_up_due", "chat.reminder_due", "record.activation"];
+/** One pushed event type. */
+type EverfurNotificationEventType = (typeof EVERFUR_NOTIFICATION_EVENT_TYPES)[number];
+/** What a tapped notification is about, keyed on `kind`. The optional references are null when the push carried none. */
+type EverfurNotificationTarget = {
+    /**
+     * A records request (`record_request.updated`, `record.ready`, and `record.activation`, which says what the
+     * request's parse found): open that request.
+     */
+    readonly kind: 'record_request';
+    readonly requestId: RecordsRequestId;
+    readonly petRef: PetRef | null;
+} | {
+    /** A pet: `pet.vaccination.due` opens that pet's records, `chat.reminder_due` that pet's chat. */
+    readonly kind: 'pet';
+    readonly petRef: PetRef;
+} | {
+    /**
+     * A vet visit (`visit.*`): open that visit. `visitRef` is the partner visit reference the visit events carry.
+     * `intent` is what to open for it, derived from the event type with the consumer app's routing (the push
+     * itself carries none): `visit` for a booking or a change to it, `join` for a reminder, `messages` for the
+     * vet's reply or the follow-up, `summary` for a completed visit. Pass both to `useVetVisit().openVisit`.
+     * `null` for a cancelled or missed visit: there is nothing left to open, so route to a new booking.
+     */
+    readonly kind: 'visit';
+    readonly visitRef: string;
+    readonly petRef: PetRef | null;
+    readonly intent: VetVisitIntent | null;
+} | {
+    /** A follow-up case (`chat.follow_up_due`): open the conversation the check-in landed in. */
+    readonly kind: 'case';
+    readonly caseRef: string;
+    readonly conversationId: ConversationId | null;
+    readonly petRef: PetRef | null;
+};
+/** A parsed push: the event it announces and the thing to open. Frozen. */
+interface EverfurNotification {
+    /** `evt_` plus the public event id, the same id the webhook envelope for this event carries. */
+    readonly eventId: string;
+    readonly eventType: EverfurNotificationEventType;
+    readonly target: EverfurNotificationTarget;
+}
+/**
+ * Read the Everfur routing block out of a received push, or null when there is none or it is not one Everfur would
+ * send. Pure and total: it never throws, whatever it is handed.
+ *
+ * Pass the object your notification library gave you: an expo-notifications `Notification` or `NotificationResponse`,
+ * an FCM `RemoteMessage`, or its `data` map. Route on `target.kind`; `eventType` says why the push was sent.
+ */
+declare function parseEverfurNotification(payload: unknown): EverfurNotification | null;
+
+export { type DevicePlatform as D, type EverfurNotificationsOptions as E, NOTIFICATIONS_REASON_MESSAGES as N, type PushProvider as P, type RegisterDeviceInput as R, type EverfurNotificationsState as a, EVERFUR_NOTIFICATION_EVENT_TYPES as b, EVERFUR_NOTIFICATION_TARGET_KINDS as c, EVERFUR_NOTIFICATION_VERSION as d, type EverfurNotification as e, type EverfurNotificationEventType as f, type EverfurNotificationTarget as g, type EverfurNotificationTargetKind as h, type EverfurNotificationsStatus as i, type NotificationPreferences as j, type NotificationPreferencesInput as k, type NotificationsClient as l, type NotificationsReasonCode as m, type NotificationsRuntime as n, type RegisteredDevice as o, createNotificationsClient as p, explainNotificationsReason as q, parseEverfurNotification as r, useEverfurNotifications as s, useEverfurNotificationsClient as u };