@everfur/sdk 0.4.0 → 0.5.1

package/dist/{bookingCopy-CqtDYvCR.d.ts → bookingCopy-SDkXaxDf.d.ts}

@@ -1,8 +1,10 @@
-import { c as EverfurResult, E as EverfurError } from './EverfurResult-DN9pL2Ab.js';
-import { R as RequestFunnel } from './requestFunnel-DFMGcluw.js';
-import { A as AuthContext } from './identity-CEi9GRFZ.js';
-import { E as ErrorPolicyPort } from './ErrorPolicyPort-CwbfmxzJ.js';
+import { E as EverfurError } from './EverfurError-DmELDpXp.js';
+import { E as EverfurResult } from './EverfurResult-SGvHKsCB.js';
+import { R as RequestFunnel } from './requestFunnel-FvE5yLDD.js';
+import { A as AuthContext } from './identity-Dy_L7Yq4.js';
+import { E as ErrorPolicyPort } from './ErrorPolicyPort-D22LUVrK.js';
 import { T as TelemetryPort } from './TelemetryPort-BDNr00hu.js';
+import { b as VetCallCredential, c as VetCallJoinRefusal } from './callRoom-7wrE3RP2.js';
 
 /** The consult lifecycle, as the platform names it. `unknown` for a status this SDK build has not heard of. */
 declare const CONSULT_STATUSES: readonly ["scheduled", "in_progress", "awaiting_summary", "completed", "cancelled_owner", "cancelled_ops", "no_show_owner", "no_show_vet"];
@@ -89,6 +91,13 @@ interface TelevetConsult {
     readonly kind: ConsultKind;
     readonly scheduledAt: string;
     readonly emergencyFlagged: boolean;
+    /**
+     * Has the visit's video room been created? Read from the presence of `meeting_url`, which is the same
+     * signal the backend's `assert_joinable` checks; the URL itself is NOT kept, because the room credential
+     * is minted by the join and a list read is the last place to hold a link to a recorded clinical room.
+     * False moments after booking, while the provisioning outbox drains.
+     */
+    readonly hasRoom: boolean;
 }
 /** The televet entitlement verdict. True only for a live PAID subscription; promo and trial are not enough. */
 interface TelevetBookingEntitlement {
@@ -162,6 +171,26 @@ declare const REASON_TEXT_MAX = 2000;
 declare const MEDIA_REFS_MAX = 10;
 /** A two-letter US state code, the only shape the booking wire accepts for `state`. */
 declare function isWellFormedStateCode(state: string | null | undefined): boolean;
+/**
+ * What cancelling cost, as the server recorded it (`CancelConsultResponse`).
+ *
+ * `summary` IS THE SERVER'S SENTENCE, rendered verbatim: it is derived from the amount the cancel transaction
+ * itself computed, and the backend states the one rule it keeps (a recorded fee is worded as recorded and
+ * payable, never as "you will not be charged"). A client-side sentence built from `feeCents` would be a
+ * second author for a commercial statement.
+ */
+interface TelevetCancelReceipt {
+    /** What was recorded against this cancellation, in cents. Zero inside the free window. */
+    readonly feeCents: number;
+    /** ISO-4217, lowercase. */
+    readonly currency: string;
+    /** The flag to branch on, rather than comparing `feeCents` to zero or parsing `summary`. */
+    readonly feeRecorded: boolean;
+    /** The served sentence for the confirmation. Null when the server sent none; never composed here. */
+    readonly summary: string | null;
+}
+/** The server's own bound on a cancellation reason (`PartnerCancelRequest.reason`, 1..240). */
+declare const CANCEL_REASON_MAX = 240;
 
 /** The partner booking surface, relative to the API base. One prefix, so a dark tenant is dark for all of it. */
 declare const TELEVET_BOOKING_BASE = "/widget/v1/televet";
@@ -177,6 +206,20 @@ declare const TELEVET_BOOKING_BASE = "/widget/v1/televet";
 declare function televetHoldCall(slotId: string): string;
 /** What a consult reschedule is addressed to. */
 declare function televetRescheduleCall(consultId: string): string;
+/** One consult of this member's. */
+declare function televetConsultCall(consultId: string): string;
+/** What minting the room credential is addressed to. */
+declare function televetJoinCall(consultId: string): string;
+/** What a cancellation is addressed to. */
+declare function televetCancelCall(consultId: string): string;
+/**
+ * How many of the member's consults one read asks for: the route's own maximum.
+ *
+ * The consumer app's reasoning, carried over (everfur-mobile televetApi.ts `listConsults`): the route defaults
+ * to 50, answers a bare list with no cursor to resend, and documents its cursor as opaque, so a client can
+ * neither page nor mint one. Asking for the maximum is the honest ceiling until the server returns a cursor.
+ */
+declare const TELEVET_CONSULT_PAGE_LIMIT = 100;
 /**
  * The booking port every ported screen reads through.
  *
@@ -186,9 +229,9 @@ declare function televetRescheduleCall(consultId: string): string;
  * route produces.
  */
 interface TelevetBookingController {
-    /** What this US state permits. A dark route answers a policy with both facts false. */
+    /** What this US state permits. A dark route settles its 404 as an error, never as a refusal. */
     statePolicy?(state: string, signal?: AbortSignal): Promise<EverfurResult<TelevetStatePolicy>>;
-    /** Whether this member's plan covers a video visit. A dark route answers `{active: false}`. */
+    /** Whether this member's visit is covered. A dark route settles its 404 as an error, never as `{active: false}`. */
     entitlement?(signal?: AbortSignal): Promise<EverfurResult<TelevetBookingEntitlement>>;
     /**
      * The cancellation terms and their version token. A dark route answers null, and the review screen then
@@ -213,6 +256,17 @@ interface TelevetBookingController {
     book(body: TelevetBookingBody, idempotencyKey: string): Promise<EverfurResult<TelevetConsult>>;
     /** Move an existing consult to an already-held slot. One server operation, not a book-then-cancel. */
     reschedule(consultId: string, slotId: string): Promise<EverfurResult<TelevetConsult>>;
+    /** This member's visits, newest first. A dark route answers an empty list. */
+    listConsults?(signal?: AbortSignal): Promise<EverfurResult<readonly TelevetConsult[]>>;
+    /** One of this member's visits. A 404 is the opaque "not this member's, or dark" answer, and is an error. */
+    getConsult?(consultId: string, signal?: AbortSignal): Promise<EverfurResult<TelevetConsult>>;
+    /**
+     * Mint the room credential for a visit whose join window is open. ONE ATTEMPT: every mint is a new token
+     * and, on the clinician's side, a new arrival, so a retry is the member's to ask for.
+     */
+    joinConsult?(consultId: string): Promise<EverfurResult<VetCallCredential>>;
+    /** Cancel a visit, answering what it cost. `reason` is the member's own words, 1 to 240 characters. */
+    cancelConsult?(consultId: string, reason: string): Promise<EverfurResult<TelevetCancelReceipt>>;
 }
 interface TelevetBookingControllerDeps {
     readonly auth: AuthContext;
@@ -237,7 +291,199 @@ interface TelevetBookingControllerDeps {
 declare function validateBookingBody(body: TelevetBookingBody): string | null;
 declare function createTelevetBookingController(deps: TelevetBookingControllerDeps): Required<TelevetBookingController>;
 
-type TelevetBookingStep = 'pet' | 'clinician' | 'time' | 'reason' | 'review' | 'booked';
+/**
+ * The classifier's answer about one piece of free text.
+ *
+ * TWO FIELDS, AND `fallback` IS NOT A FAILURE. The consumer treats "the classifier could not give a verdict"
+ * as an emergency for this purpose, because the booking route refuses it the same way
+ * (useEarlyTriage.ts:70: `verdict.isEmergency || verdict.fallback`). A read that never completed is a
+ * different thing and is handled by the absence of a verdict, not by a field on one.
+ */
+interface TelevetTriageVerdict {
+    readonly isEmergency: boolean;
+    /** The classifier ran and declined to decide. Refused like an emergency, by the booking route and here. */
+    readonly fallback: boolean;
+}
+/**
+ * The seam the triage read arrives through.
+ *
+ * A PROMISE THAT RESOLVES TO NULL, NEVER A REJECTION THE CALLER HAS TO CATCH: null means "no verdict" (the
+ * route is dark, the request failed, the owner left), which this hook treats as "go on". A host or the
+ * controller supplies it; absent, no question is asked.
+ */
+type TelevetTriageRead = (reasonText: string, signal: AbortSignal) => Promise<TelevetTriageVerdict | null>;
+interface TelevetEarlyTriage {
+    /** The warning is up. While true the flow must not advance past Describe. */
+    readonly open: boolean;
+    /** A read is in flight. The Continue control shows it rather than appearing dead. */
+    readonly checking: boolean;
+    /** True when the flow should go on; false when it must not move (a warning opened, or a read is running). */
+    check(reasonText: string): Promise<boolean>;
+    /** "I have handled this, keep booking", recorded against the EXACT words it was answered for. */
+    acknowledge(reasonText: string): void;
+    /** Back from the warning: closes it without recording an acknowledgement. */
+    close(): void;
+    /** Abort an in-flight read (unmount, or leaving the step). */
+    cancel(): void;
+    /** A different pet is a different booking: its words are asked about afresh. */
+    reset(): void;
+    /** Whether these exact words carry an acknowledgement, so the booking body can say so truthfully. */
+    isAcknowledged(reasonText: string): boolean;
+}
+/**
+ * The hook. `read` absent (a dark tenant, or a host that wired no seam) means `check` always answers "go on",
+ * which is the same behaviour as a read that failed and is deliberately indistinguishable from it.
+ */
+declare function useEarlyTriage(read: TelevetTriageRead | null | undefined): TelevetEarlyTriage;
+
+/**
+ * The server's own demand bucket. A CLOSED SET, and callers may not substitute free text.
+ *
+ * THE TWO ARE CLOSED BY DIFFERENT FIXES, which is why the server distinguishes them and why a call site that
+ * guesses is wrong in a way nobody can see: `no_licensed_vet` is closed by licensing a clinician in that
+ * state, `no_prescribing` by a change in what that state permits remotely. The consumer container is explicit
+ * about picking the first for an empty roster and for a blocked state
+ * (TelevetBookingContainer.tsx, the `no_licensed_vet, not no_prescribing` comment).
+ */
+type TelevetStateInterestReason = 'no_licensed_vet' | 'no_prescribing';
+/** What the control needs to render its lifecycle. Null means there is nothing to render; see the header. */
+interface TelevetStateInterestAction {
+    /** The write SUCCEEDED in this session. Never inferred, never optimistic. */
+    readonly joined: boolean;
+    readonly pending: boolean;
+    readonly failed: boolean;
+    onPress(): void;
+}
+/**
+ * The seam the write goes through. Resolves true on a recorded interest and false otherwise; a rejection is
+ * caught here and read as false, so a host cannot turn a throw into a silent success.
+ */
+type TelevetStateInterestWrite = (state: string, reason: TelevetStateInterestReason) => Promise<boolean>;
+/**
+ * Local, per-mounted-booking feedback for the owner-initiated state-interest write.
+ *
+ * LOCAL SUCCESS IS DELIBERATELY EPHEMERAL, verbatim from the consumer's reasoning: the server is idempotent,
+ * so this only prevents repeat taps in this session and "does not pretend we know the owner's durable
+ * subscription state" (useBookingStateInterest.ts:20-25). Nothing here is persisted, because a remembered
+ * "you are on the list" that outlived a state change would be a claim this client cannot stand behind.
+ */
+declare function useStateInterest(state: string | null | undefined, write: TelevetStateInterestWrite | null | undefined): {
+    actionFor(reason: TelevetStateInterestReason): TelevetStateInterestAction | null;
+};
+
+/** Why the roster is empty. Closed, because each value picks a different true sentence. */
+type TelevetEmptyRosterCause = 
+/** A real, state-scoped read answered a literal empty list. A licensure gap. */
+'roster'
+/** The route is dark for this tenant, so no read happened. Not a licensure fact. */
+ | 'dark';
+/** What the empty-roster screen renders. Derived, never chosen at a call site. */
+interface TelevetEmptyRosterView {
+    readonly title: string;
+    readonly message: string;
+    /**
+     * The retry label, or null when a retry cannot help.
+     *
+     * NULL IS LOAD BEARING and is not a styling preference. `TelevetStateCard` renders its action only when a
+     * label AND a handler are both present, so a null label removes the control rather than disabling it. A
+     * `Check again` on a licensure gap is a button whose every press repeats the same answer.
+     */
+    readonly retryLabel: string | null;
+    /**
+     * Which demand bucket a state-interest write would carry from this screen, or null when interest cannot be
+     * offered here.
+     *
+     * `no_licensed_vet`, NOT `no_prescribing`, and only on the licensure cause. The server treats the two as
+     * distinct fixes; this one is closed by licensing a clinician in the state, which is exactly what an empty
+     * state-scoped roster reports. Offering interest on the DARK cause would record a demand signal for a
+     * state nobody established anything about.
+     */
+    readonly interestReason: 'no_licensed_vet' | null;
+}
+/**
+ * The view for an empty roster, from the cause.
+ *
+ * A PURE FUNCTION over the copy deck, so both platform ports read the same three fields and neither can pick
+ * its own sentence. It takes the CAUSE rather than a boolean, because a boolean at a call site is how the
+ * dark tenant and the licensure gap got the same words in the first place.
+ */
+declare function televetEmptyRosterView(cause: TelevetEmptyRosterCause): TelevetEmptyRosterView;
+/**
+ * The cause, from what the flow knows.
+ *
+ * `surfaceServed` IS THE CALLER'S ONE FACT: has anything on this booking surface answered a real response?
+ * The container derives it from the reads it has already made, and it is deliberately NOT re-derived here
+ * from a 404, because `clinicians` has already swallowed that into `ok([])` by the time a screen sees it.
+ * That swallow is the right call for rendering and the wrong one for this decision, which is exactly why
+ * the fact has to be carried alongside the empty list rather than recovered from it.
+ */
+declare function televetEmptyRosterCause(surfaceServed: boolean): TelevetEmptyRosterCause;
+
+/**
+ * Why a pick was refused before it was ever sent.
+ *
+ * THE CONSUMER'S OWN THREE BUCKETS, not a set invented here: mobile's `ConsultAttachmentOutcome.refused` and
+ * the web app's `ConsultAttachmentRefusal` both carry exactly `size`, `type` and `unreadable`, and each has a
+ * ported sentence. A fourth cause with no consumer sentence would have nothing to say, so the type is closed.
+ */
+type TelevetMediaRefusal = 'size' | 'type' | 'unreadable';
+/** Counts of what did not reach the vet, by cause. The consumer web app's `ConsultAttachmentShortfall`. */
+interface TelevetMediaShortfall {
+    /** Passed the rules, then the send did not carry it. On this surface that is every pick; see the header. */
+    readonly failed: number;
+    readonly refused: Readonly<Record<TelevetMediaRefusal, number>>;
+}
+/** Nothing to say. Frozen and shared so a caller cannot mutate the empty case into a false report. */
+declare const NO_MEDIA_SHORTFALL: TelevetMediaShortfall;
+/** True when there is literally nothing to tell the owner. */
+declare function isMediaShortfallEmpty(shortfall: TelevetMediaShortfall): boolean;
+/**
+ * One sentence per cause, in the consumer's order, or an empty list when there is nothing to say.
+ *
+ * THE ORDER IS THE CONSUMER'S AND IS NOT ALPHABETICAL: dropped, then size, then type, then unreadable. Both
+ * consumer apps list them that way (MediaDropNotice.tsx:31-36 and consultAttachmentUpload.ts:385-403), which
+ * puts the thing that got furthest through the flow first.
+ *
+ * A NEGATIVE OR NON-FINITE COUNT IS TREATED AS ZERO rather than trusted. These numbers can arrive from a
+ * host's own upload seam, and `{n}` is interpolated straight into a sentence an owner reads: "-1 attachment
+ * did not upload." is a defect wearing a report. It is floored rather than thrown on, because failing a
+ * booking confirmation over a bad count would cost the owner the one screen that tells them anything.
+ */
+declare function televetMediaShortfallLines(shortfall: TelevetMediaShortfall): readonly string[];
+/**
+ * The shortfall THIS SURFACE actually has: every pick the owner made, reported as not sent.
+ *
+ * WHY THIS FUNCTION EXISTS AT ALL, and why it is not a stub for a future upload. The consumer apps derive
+ * their shortfall from an upload RESULT. The SDK has no upload: `media_refs` leaves as `[]` whatever the
+ * owner picked, and that is a decision with a written reason (no confirmed ref format, no read path, no
+ * attachment purpose on the partner plane), not a gap about to close. So the honest count is knowable
+ * without a network call: it is the length of the tray.
+ *
+ * `failed`, NOT A REFUSAL BUCKET. The picks passed every local rule - the row accepted them, capped them at
+ * `MEDIA_REFS_MAX` and showed them as thumbnails. Nothing about their size, type or readability is why they
+ * did not arrive. "{n} attachments did not upload." is the true sentence; "too large to send" would be a
+ * false explanation, and a false explanation invites the owner to re-pick a smaller photo that will be
+ * dropped in exactly the same way.
+ *
+ * IT REPORTS ZERO WHEN THE TRAY IS EMPTY, so the notice mounts unconditionally and renders nothing on the
+ * common path, which is the property the consumer component was built around (MediaDropNotice.tsx:19-20).
+ */
+declare function mediaShortfallFromUnsentPicks(pickCount: number): TelevetMediaShortfall;
+/**
+ * Add a refusal the ATTACHMENT ROW itself made, so a silently discarded pick is stated.
+ *
+ * THE ROW ALREADY DISCARDS PICKS AND SAID NOTHING. `IntakeMedia` drops a pick whose uri is already attached
+ * and then `.slice(0, MEDIA_REFS_MAX)` cuts whatever is past the cap. Both are correct behaviours and both
+ * were silent, so an owner who selected eight photos into a tray with three slots left saw five of them
+ * vanish with no explanation. The consumer mobile app's cap refusal is `size`; this one is neither a size
+ * nor a type nor an unreadable file, so it is reported as `failed` for the same reason the unsent picks are:
+ * it is the only one of the four sentences that is TRUE, and a true vague sentence beats a false precise one.
+ *
+ * Returns a new object; the input is never mutated (house rule, and these are frozen anyway).
+ */
+declare function withUnsentPicks(shortfall: TelevetMediaShortfall, pickCount: number): TelevetMediaShortfall;
+
+type TelevetBookingStep = 'pet' | 'issues' | 'clinician' | 'time' | 'reason' | 'review' | 'booked';
 /**
  * Ordered for the progress rail. `booked` is terminal and counts toward nothing: the flow is over, and
  * including it would show a rail at 6/7 on a screen with no next step.
@@ -265,6 +511,8 @@ declare const emptyTelevetDraft: TelevetBookingDraft;
 interface TelevetBookingContext {
     /** Skips the picker for a single-pet household. */
     readonly ownedPetCount: number;
+    /** Shows the issues step. The web flow sets it, mirroring the consumer web funnel; absent, it is skipped. */
+    readonly withIssues?: boolean;
 }
 interface TelevetBookingState {
     readonly index: number;
@@ -366,6 +614,82 @@ declare function attestation(stateAttested: boolean, termsAttested: boolean, pol
     readonly cancellation_policy_version: string;
 } | Record<string, never>;
 
+/**
+ * Why a booking did not complete.
+ *
+ * DECLARED HERE because this module is what produces every value, and both platform containers re-export it
+ * as their own `TelevetBookingFailure` so a host's existing import keeps working. `not_entitled` is separate
+ * from `failed` because the two need opposite affordances: a transient failure invites a retry and a 402
+ * must not. `unavailable` is separate from both because no retry can succeed.
+ */
+type TelevetBookingFailure = 'taken' | 'expired' | 'failed' | 'not_entitled'
+/** The remedy is a DIFFERENT VET, not a different time: re-picking a slot with the same clinician refuses again. */
+ | 'clinician_unavailable'
+/** Per-owner caps. The remedy is WAITING, so this must never render as an invitation to press again. */
+ | 'rate_limited'
+/** The partner booking surface is dark here. No retry can fix it, so the flow says so and offers its exit. */
+ | 'unavailable' | null;
+
+/** How early the join arms, in minutes before `scheduled_at`. Both consumer apps: 15. */
+declare const TELEVET_JOIN_OPENS_MINUTES_BEFORE = 15;
+/** How late the join stays armed, in minutes after `scheduled_at`: 10 minute consult plus a 4 hour grace. */
+declare const TELEVET_JOIN_CLOSES_MINUTES_AFTER = 250;
+/** When the join window opens, as epoch milliseconds; null for an unreadable time. */
+declare function televetJoinOpensAtMs(consult: Pick<TelevetConsult, 'scheduledAt'>): number | null;
+/** The mobile readiness: ready, or why not. */
+type TelevetJoinReadiness = {
+    readonly ready: true;
+} | {
+    readonly ready: false;
+    readonly reason: 'not_open_yet' | 'consult_over';
+};
+/**
+ * May the member press Join now? The consumer MOBILE rule, verbatim in order.
+ *
+ * `in_progress` BEATS THE CLOCK: the server is asserting the call is happening, and refusing on our own
+ * arithmetic would lock the member out of a call their vet is sitting in. AN UNREADABLE TIME DOES NOT ARM THE
+ * BUTTON: opening a room for a visit whose time we cannot read is worse than a stated "not yet".
+ */
+declare function televetJoinReadiness(consult: TelevetConsult | null, nowMs: number): TelevetJoinReadiness;
+/**
+ * Why the web row's Join is dark, in the backend's own vocabulary (`assert_joinable`'s 409 `detail.reason`):
+ * `status_{status}` for a visit that is not scheduled or in progress, `room_not_ready` for a visit whose
+ * video room has not been created yet, and the two window edges.
+ */
+type TelevetJoinBlock = 'too_early' | 'too_late' | 'room_not_ready' | `status_${string}`;
+type TelevetJoinDecision = {
+    readonly joinable: true;
+} | {
+    readonly joinable: false;
+    readonly reason: TelevetJoinBlock;
+};
+/**
+ * May the member press Join now? The consumer WEB rule, which mirrors the backend's order: STATUS FIRST, so a
+ * cancelled visit reads as cancelled rather than as "too late"; THE ROOM BEFORE THE WINDOW, so a member who
+ * opens the page moments after booking hears that the room is being set up rather than that they are early.
+ */
+declare function televetJoinDecision(consult: TelevetConsult, nowMs: number): TelevetJoinDecision;
+/**
+ * The visits, split into what is still ahead and what is over. Both consumer apps' `splitConsults` /
+ * `splitVisits`, which agree.
+ *
+ * A visit is UPCOMING while its status is one the member could still join AND its join window has not
+ * closed: the same two facts the Join control reads, so a row can never be joinable and filed under the past
+ * at once. `awaiting_summary` is not upcoming: the call has ended. Upcoming is soonest first, because the visit
+ * that needs the member next belongs at the top; the past is newest first. An unreadable time sinks to the
+ * past rather than corrupting the sort.
+ */
+declare function splitTelevetVisits(consults: readonly TelevetConsult[], nowMs: number): {
+    readonly upcoming: readonly TelevetConsult[];
+    readonly past: readonly TelevetConsult[];
+};
+/**
+ * May the member move or cancel this visit? Only while it is SCHEDULED, which is the backend writer's own
+ * lock (`_lock_scheduled`) and both consumer apps' predicate. `awaiting_summary` is non-terminal only because
+ * the clinician may still write the record; offering Cancel there invites a refusal for a visit that happened.
+ */
+declare function canManageTelevetVisit(status: ConsultStatus): boolean;
+
 /** One read, in the shape the ported screens branch on. */
 interface TelevetRead<T> {
     /** False when the question cannot be asked yet. A disabled read is never pending and never errors. */
@@ -447,6 +771,23 @@ declare function useTelevetBookConsult(controller: TelevetBookingController | nu
 /** Move an existing consult to an already-held slot. */
 declare function useTelevetRescheduleConsult(consultId: string | null, controller: TelevetBookingController | null): TelevetWrite<[slotId: string], TelevetConsult>;
 
+/** Where a join is. `reason` is the server's own refusal reason, for a surface that words each one. */
+type TelevetJoinState = {
+    readonly status: 'joining';
+} | {
+    readonly status: 'ready';
+    readonly credential: VetCallCredential;
+} | {
+    readonly status: 'refused';
+    readonly refusal: VetCallJoinRefusal;
+    readonly reason: string | null;
+};
+/** Mint the room credential for `consultId` on mount; `retry` asks again. */
+declare function useTelevetJoin(consultId: string, controller: TelevetBookingController | null): {
+    readonly state: TelevetJoinState;
+    readonly retry: () => void;
+};
+
 type TelevetBookingRefusal = 
 /** Triage flagged an emergency. Carries `categories`. MUST show the warning. */
 {
@@ -487,8 +828,8 @@ type TelevetBookingRefusal =
  *
  * NOT IN THE CONSUMER'S UNION, and it is the one member the port adds. The consumer app talks to its own
  * consumer surface, which is either on or dark for everybody; a PARTNER integration can have vet visits
- * granted and the in-app booking routes withheld, and the remedy there is the hosted handoff rather than any
- * retry. Folding it into `failed` would offer a retry that can never work.
+ * granted and the in-app booking routes withheld, and no retry fixes that: the flow shows its unavailable
+ * state, inside the partner app. Folding it into `failed` would offer a retry that can never work.
  */
  | {
     readonly kind: 'unavailable';
@@ -524,6 +865,7 @@ declare const TELEVET_BOOKING_COPY: Readonly<{
     /** WHY, not just "none". An empty roster is a real, temporary answer. */
     noCliniciansBody: string;
     noCliniciansRetryCta: string;
+    noCliniciansRegionBody: string;
     /** The matched vet, not a roster. */
     yourVetTitle: string;
     /** Suffix on the star line: "5.0 · 774 reviews". */
@@ -548,6 +890,59 @@ declare const TELEVET_BOOKING_COPY: Readonly<{
     shareRecordsOff: string;
     confirmNotEntitled: string;
     confirmFailed: string;
+    checkAvailabilityCta: string;
+    /**
+     * THE STATE-INTEREST WRITE: the one way out of a refusal this flow cannot fix.
+     *
+     * PORTED FROM BOTH CONSUMER APPS, which agree on every string. Mobile's `liveVetCopy.region.waitlist*`
+     * (everfur-mobile src/features/liveVet/copy.ts:202-209, rendered by
+     * `TelevetStateInterestAction.tsx:27-51`) and the consumer WEB app's `ownerTelevetCopy.stateInterest*`
+     * (everfur-frontend app/product/televet/ownerCopy.ts:520-527, rendered by
+     * `StateInterestPanel.tsx:100-130`) are the same words. `submitting` exists only on the web side
+     * (ownerCopy.ts:524); mobile renders the pending state as a spinner inside its button instead, so the
+     * RN port uses `loading` and the DOM port uses this label, each following its own consumer app.
+     *
+     * NOT `waitlist` IN THE KEY NAMES. The server's enum calls this state interest and buckets it by REASON
+     * (`no_licensed_vet` vs `no_prescribing`), and the two are closed by different fixes. Naming the keys
+     * after the UI word would invite a call site to post the wrong bucket.
+     */
+    stateInterest: Readonly<{
+        cta: string;
+        /** Web only. Mobile shows a spinner in the button; see the block comment above. */
+        submitting: string;
+        joinedTitle: string;
+        joinedBody: string;
+        failed: string;
+    }>;
+    /**
+     * WHAT HAPPENED TO THE OWNER'S ATTACHMENTS, one sentence per cause.
+     *
+     * PORTED FROM BOTH CONSUMER APPS, which again agree character for character: mobile's
+     * `liveVetCopy.booking.media*Template` (everfur-mobile src/features/liveVet/copy.ts:484-491, rendered by
+     * `MediaDropNotice.tsx:31-36`) and the consumer WEB app's `ownerTelevetCopy.media.*Template`
+     * (everfur-frontend app/product/televet/ownerCopy.ts:486-494, rendered through
+     * `consultAttachmentShortfallLines` in consultAttachmentUpload.ts:382-407, whose own docblock calls itself
+     * "mobile's `MediaDropNotice` in pure form").
+     *
+     * `{n}` IS DATA and is filled at the call site through `fill`. Singular and plural are separate keys
+     * rather than a pluralisation rule, because that is what both consumer apps do and a rule invented here
+     * would produce a third grammar for the same sentence.
+     *
+     * WHY THIS DECK CARRIES `dropped` AT ALL, given the SDK never uploads. See `mediaShortfall.ts`: the SDK's
+     * booking sends `media_refs: []` unconditionally, so on this surface EVERY attachment an owner picked is
+     * dropped, and `dropped` is the sentence for exactly that. It is the most load-bearing line here, not a
+     * spare one.
+     */
+    media: Readonly<{
+        droppedTemplate: string;
+        droppedPluralTemplate: string;
+        refusedSizeTemplate: string;
+        refusedSizePluralTemplate: string;
+        refusedTypeTemplate: string;
+        refusedTypePluralTemplate: string;
+        refusedUnreadableTemplate: string;
+        refusedUnreadablePluralTemplate: string;
+    }>;
     navTitle: string;
     /** The chrome must not say "Book a visit" while the user is moving one they already have. */
     rescheduleNavTitle: string;
@@ -610,15 +1005,23 @@ declare const TELEVET_BOOKING_COPY: Readonly<{
     /**
      * The emergency refusal. This is the one screen on the surface that interrupts.
      *
-     * WHAT IS DELIBERATELY MISSING, in the consumer and here: the three exit rows (find an ER, poison control,
-     * call the primary vet). Those need a dialled number and the pet's primary vet, and NO number may be
-     * invented for a screen an owner reads in an emergency. The warning and the acknowledgement are wired; the
-     * exits are a separate build with real data behind them.
+     * THE EXIT ROWS. This used to say the three rows were missing "in the consumer and here", which was wrong
+     * twice: the consumer mobile screen draws the find-a-vet row and the primary-vet row
+     * (TelevetEarlyEmergency.tsx:73-75, :91) and the consumer web draws all three with poison control
+     * (BookingFunnel.tsx:713-774). The RN screens now draw the mobile two, the find row only when the host
+     * passes its own locator (`onFindEmergencyVet`, the SDK opens nothing outside the app) and the clinic row
+     * only when the host holds the clinic (`primaryVet`). The web screens draw the web cards from
+     * `bookingCopyWeb.ts` on the same two host seams, with poison control held for the owner's approval (see
+     * `src/web/televet/booking/EmergencyExits.tsx`). No number is ever invented for this screen.
      */
     emergency: Readonly<{
         bannerTitle: string;
         keepBookingCta: string;
         lede: string;
+        exitPrimaryVetTitle: string;
+        /** everfur-mobile copy.ts:734 `emergency.exitFindErTitle`, the consumer web's `findEmergencyVet` word for word. */
+        exitFindErTitle: string;
+        startCallHint: string;
     }>;
     /** The calendar entry's own title, from the consumer's `visit` block. */
     visit: Readonly<{
@@ -729,4 +1132,4 @@ type TelevetBookingCopy = typeof TELEVET_BOOKING_COPY;
  */
 declare function isTelevetBookingCopyReady(): boolean;
 
-export { useTelevetBookingEntitlement as $, type TelevetWrite as A, attestation as B, CANCELLATION_POLICY_VERSION_MAX as C, canConfirm as D, createTelevetBookingController as E, currentStep as F, emptyTelevetDraft as G, formatVisitRange as H, formatWhen as I, formatWhenWithDay as J, hasPreviousStep as K, initialTelevetBookingState as L, MEDIA_REFS_MAX as M, isHoldExpired as N, isSkipped as O, isTelevetBookingCopyReady as P, isWellFormedStateCode as Q, REASON_TEXT_MAX as R, televetBookingKey as S, type TelevetConsult as T, televetBookingReducer as U, televetBookingRefusal as V, televetHoldCall as W, televetRescheduleCall as X, useTelevetBookConsult as Y, useTelevetBookingAvailable as Z, useTelevetBookingController as _, type TelevetBookingStep as a, useTelevetCancellationPolicy as a0, useTelevetClinicians as a1, useTelevetHoldSlot as a2, useTelevetNextSlot as a3, useTelevetRescheduleConsult as a4, useTelevetSlots as a5, useTelevetStatePolicy as a6, validateBookingBody as a7, type TelevetBookingController as b, type TelevetSlot as c, CONSULT_KINDS as d, CONSULT_MINUTES as e, CONSULT_STATUSES as f, type ConsultKind as g, type ConsultStatus as h, TELEVET_BOOKING_BASE as i, TELEVET_BOOKING_COPY as j, TELEVET_BOOKING_STEPS as k, TERMINAL_CONSULT_STATUSES as l, type TelevetBookingAction as m, type TelevetBookingBody as n, type TelevetBookingContext as o, type TelevetBookingControllerDeps as p, type TelevetBookingCopy as q, type TelevetBookingDraft as r, type TelevetBookingEntitlement as s, type TelevetBookingRefusal as t, type TelevetBookingState as u, type TelevetCancellationPolicy as v, type TelevetClinician as w, type TelevetRead as x, type TelevetSlotHold as y, type TelevetStatePolicy as z };
+export { createTelevetBookingController as $, type TelevetBookingCopy as A, type TelevetBookingDraft as B, CANCELLATION_POLICY_VERSION_MAX as C, type TelevetBookingEntitlement as D, type TelevetBookingFailure as E, type TelevetBookingRefusal as F, type TelevetBookingState as G, type TelevetCancellationPolicy as H, type TelevetClinician as I, type TelevetEarlyTriage as J, type TelevetEmptyRosterView as K, type TelevetJoinReadiness as L, MEDIA_REFS_MAX as M, NO_MEDIA_SHORTFALL as N, type TelevetJoinState as O, type TelevetMediaRefusal as P, type TelevetRead as Q, REASON_TEXT_MAX as R, type TelevetSlotHold as S, type TelevetEmptyRosterCause as T, type TelevetStateInterestReason as U, type TelevetStatePolicy as V, type TelevetTriageVerdict as W, type TelevetWrite as X, attestation as Y, canConfirm as Z, canManageTelevetVisit as _, type TelevetStateInterestAction as a, currentStep as a0, emptyTelevetDraft as a1, formatVisitRange as a2, formatWhen as a3, formatWhenWithDay as a4, hasPreviousStep as a5, initialTelevetBookingState as a6, isHoldExpired as a7, isMediaShortfallEmpty as a8, isSkipped as a9, useTelevetJoin as aA, useTelevetNextSlot as aB, useTelevetRescheduleConsult as aC, useTelevetSlots as aD, useTelevetStatePolicy as aE, validateBookingBody as aF, withUnsentPicks as aG, type TelevetJoinBlock as aH, type TelevetJoinDecision as aI, televetJoinDecision as aJ, isTelevetBookingCopyReady as aa, isWellFormedStateCode as ab, mediaShortfallFromUnsentPicks as ac, splitTelevetVisits as ad, televetBookingKey as ae, televetBookingReducer as af, televetBookingRefusal as ag, televetCancelCall as ah, televetConsultCall as ai, televetEmptyRosterCause as aj, televetEmptyRosterView as ak, televetHoldCall as al, televetJoinCall as am, televetJoinOpensAtMs as an, televetJoinReadiness as ao, televetMediaShortfallLines as ap, televetRescheduleCall as aq, useEarlyTriage as ar, useStateInterest as as, useTelevetBookConsult as at, useTelevetBookingAvailable as au, useTelevetBookingController as av, useTelevetBookingEntitlement as aw, useTelevetCancellationPolicy as ax, useTelevetClinicians as ay, useTelevetHoldSlot as az, type TelevetMediaShortfall as b, type TelevetConsult as c, type TelevetBookingStep as d, type TelevetBookingController as e, type TelevetTriageRead as f, type TelevetStateInterestWrite as g, type TelevetCancelReceipt as h, type TelevetSlot as i, CANCEL_REASON_MAX as j, CONSULT_KINDS as k, CONSULT_MINUTES as l, CONSULT_STATUSES as m, type ConsultKind as n, type ConsultStatus as o, TELEVET_BOOKING_BASE as p, TELEVET_BOOKING_COPY as q, TELEVET_BOOKING_STEPS as r, TELEVET_CONSULT_PAGE_LIMIT as s, TELEVET_JOIN_CLOSES_MINUTES_AFTER as t, TELEVET_JOIN_OPENS_MINUTES_BEFORE as u, TERMINAL_CONSULT_STATUSES as v, type TelevetBookingAction as w, type TelevetBookingBody as x, type TelevetBookingContext as y, type TelevetBookingControllerDeps as z };