@everfur/sdk 0.3.0 → 0.5.0

package/dist/bookingCopy-DfuA13dh.d.cts

@@ -0,0 +1,1135 @@
+import { E as EverfurError } from './EverfurError-DmELDpXp.cjs';
+import { E as EverfurResult } from './EverfurResult-ZtH-YV1h.cjs';
+import { R as RequestFunnel } from './requestFunnel-Djjwgoe9.cjs';
+import { A as AuthContext } from './identity-C7uxGwfT.cjs';
+import { E as ErrorPolicyPort } from './ErrorPolicyPort-D6CybiqJ.cjs';
+import { T as TelemetryPort } from './TelemetryPort-BDNr00hu.cjs';
+import { b as VetCallCredential, c as VetCallJoinRefusal } from './callRoom-B_EqaUzx.cjs';
+
+/** 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"];
+type ConsultStatus = (typeof CONSULT_STATUSES)[number] | 'unknown';
+/**
+ * Statuses after which a consult can never change again.
+ *
+ * `awaiting_summary` is deliberately NOT terminal: the call is over but the write-up has not landed, and that
+ * is precisely the window a summary surface polls through.
+ */
+declare const TERMINAL_CONSULT_STATUSES: ReadonlySet<ConsultStatus>;
+declare const CONSULT_KINDS: readonly ["wellness", "prescription"];
+type ConsultKind = (typeof CONSULT_KINDS)[number] | 'unknown';
+/**
+ * What a US state permits. TWO INDEPENDENT SERVER FACTS, not one.
+ *
+ * `wellnessAvailable` and `prescriptionsAvailable` are separate because "we cannot prescribe here but a
+ * wellness visit is available" is a real state the booking flow reads, not a copy decision.
+ */
+interface TelevetStatePolicy {
+    readonly state: string;
+    readonly wellnessAvailable: boolean;
+    readonly prescriptionsAvailable: boolean;
+    /**
+     * ALWAYS NULL against a real server, and kept only so a host that reads it still compiles.
+     *
+     * `StateCapabilitiesResponse` has no `cancellation_policy_text` and never did: it is the jurisdiction
+     * matrix, and its own docstring refuses to carry a booking acknowledgement. The terms live on
+     * `GET /cancellation-policy` with the version token that makes them reportable, which is what
+     * `TelevetCancellationPolicy` and `TelevetBookingController.cancellationPolicy` read. Prefer that; this
+     * field is a wire that was never connected, left in place rather than removed because dropping a public
+     * field is a release decision, and documented rather than quietly parsed so the next surface does not
+     * build a tick on it.
+     */
+    readonly cancellationPolicyText: string | null;
+}
+/**
+ * A clinician card. BIOS ONLY AT LAUNCH, per the platform's own docstring: `photoRef` is an image REF and not a
+ * URL, so a surface that has no presign path renders initials rather than a broken image.
+ */
+interface TelevetClinician {
+    readonly clinicianId: string;
+    readonly displayName: string;
+    readonly credentials: string | null;
+    /** Null below the platform's publication threshold. NEVER coerce to 0: no stars is not zero stars. */
+    readonly rating: number | null;
+    readonly ratingCount: number | null;
+    /** The clinician's own words, or null until they write one. Rendered verbatim, never summarised. */
+    readonly bio: string | null;
+    /** An image ref, not a URL. Null for a clinician without a photo. */
+    readonly photoRef: string | null;
+    /** Where they may practise and what they may do there. Empty until served. */
+    readonly licensedStates: readonly {
+        readonly state: string;
+        readonly canPrescribe: boolean;
+    }[];
+}
+/** One bookable opening. */
+interface TelevetSlot {
+    readonly slotId: string;
+    readonly startsAt: string;
+    readonly endsAt: string;
+}
+/**
+ * An awarded hold. NO HOLD ID: the hold is identified by the slot it sits on plus an expiry, which is why the
+ * booking's idempotency key is derived from the SLOT and not from a hold reference that does not exist.
+ */
+interface TelevetSlotHold {
+    readonly slotId: string;
+    readonly expiresAt: string;
+}
+/** A booked consult, as the server created it. What we asked for is the draft; this is what we got. */
+interface TelevetConsult {
+    readonly consultId: string;
+    readonly petId: string;
+    readonly clinicianId: string;
+    /** The clinician's name, or null when the server has none. Never invented. */
+    readonly clinicianName: string | null;
+    /** What the owner wrote at booking, echoed back. */
+    readonly reasonText: string | null;
+    /** Attachment refs as stored against the consult. */
+    readonly mediaRefs: readonly string[];
+    readonly status: ConsultStatus;
+    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 {
+    readonly active: boolean;
+}
+/**
+ * The cancellation terms, and the token that says WHICH terms they are.
+ *
+ * WHY THIS IS ITS OWN READ. `TelevetStatePolicy.cancellationPolicyText` was parsed off the state-policy
+ * response, and no such field exists on it: `StateCapabilitiesResponse` carries the jurisdiction matrix and
+ * says so in its own docstring, and its `policy_version` is the state matrix's effective date, not the
+ * cancellation terms. So the terms tick could never render and there was no version to report, which is why
+ * the booking body omitted the attestation pair entirely. The server has always served this on its own route
+ * (`GET /cancellation-policy`, CancellationPolicyResponse), unfenced by entitlement precisely so someone
+ * deciding whether to book can read what cancelling costs.
+ *
+ * NEITHER FIELD IS EVER LOCAL. `summary` is the sentence the server derives from the numbers it enforces (the
+ * consumer app shipped a placeholder and a wrong hardcoded fee before this route existed), and `version` is
+ * evidence of what was on screen: a client-authored token would make the audit row a fiction, and a stale one
+ * is refused with a typed 409 rather than recorded as agreement to terms nobody saw.
+ */
+interface TelevetCancellationPolicy {
+    /** The served sentence, rendered verbatim. Never composed, templated or abbreviated by a client. */
+    readonly summary: string;
+    /** The server's own version token, reported back in `cancellation_policy_version`. */
+    readonly version: string;
+}
+/**
+ * The booking request body, in the platform's own field names. Built by `buildBookingBody`, never by hand.
+ *
+ * THE ATTESTATION PAIR IS BOUND, and the binding is the server's, not a house convention. `BookConsultRequest`
+ * declares `state_attested` and `cancellation_policy_version` individually optional and then refuses a request
+ * carrying exactly one (`_attestation_evidence_is_whole`, a 422). The compatibility case the pair is optional
+ * FOR is a client that predates the review screen and sends neither; a client that renders the tick and the
+ * terms and reports half of what the owner did writes an audit row nobody can read. So the SDK models both
+ * fields as jointly present or jointly absent and `validateBookingBody` refuses the half pair locally, before
+ * it can become a 422 the owner reads as "booking failed".
+ */
+interface TelevetBookingBody {
+    readonly pet_id: string;
+    readonly clinician_id: string;
+    readonly slot_id: string;
+    readonly state: string;
+    readonly reason_text: string;
+    readonly species: string | null;
+    readonly media_refs: readonly string[];
+    readonly emergency_acknowledged: boolean;
+    readonly share_health_records: boolean;
+    /**
+     * The review screen's jurisdiction tick, as evidence.
+     *
+     * `true` ONLY, never `false`: the server's field is `Literal[True] | None` because persisting an explicit
+     * `false` is evidence of nothing and accepting it would let a client "attest false". An owner who has not
+     * ticked sends the pair absent, not a `false` half of it.
+     */
+    readonly state_attested?: true;
+    /**
+     * Which cancellation terms the owner was SHOWN: the served version token, never a client-authored value.
+     *
+     * Paired with `state_attested` above. A stale token is refused with a typed 409 rather than recorded as if
+     * the owner had read the current terms, which is why it is the SERVER's token and why there is no local
+     * default: a build with no version to report sends the pair absent and the audit row says so honestly.
+     */
+    readonly cancellation_policy_version?: string;
+}
+/** The server's own ceiling on `cancellation_policy_version` (`Field(max_length=64)`). */
+declare const CANCELLATION_POLICY_VERSION_MAX = 64;
+/** The server's own bound on `reason_text`. Enforced locally so an over-long description fails on the screen. */
+declare const REASON_TEXT_MAX = 2000;
+/** The server's own ceiling on `media_refs`. */
+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";
+/**
+ * What taking a slot is addressed to: the slot is IN THE PATH, not in the body.
+ *
+ * THIS WAS `POST /slots/holds` WITH `{slot_id}` IN THE BODY, and it was invented rather than mirrored. The
+ * consumer route the partner plane is being built against is `POST /slots/{slot_id}/hold`
+ * (televet_consumer_router.py), a per-slot write whose rate limit and entitlement fence are both keyed on the
+ * path. A collection-style hold endpoint does not exist on either plane, so the old shape could never have
+ * matched, and nothing said so because the route table was silent about booking (see `knownRoutes.ts`).
+ */
+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.
+ *
+ * EVERY METHOD IS OPTIONAL except the three writes and the grid, because a host or a test may inject a
+ * controller that answers only what its surface needs. A missing method is treated as "that answer is not
+ * available", never as an error: `useTelevetBooking` degrades each absence to the same deliberate state a dark
+ * route produces.
+ */
+interface TelevetBookingController {
+    /** 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 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
+     * omits the terms tick and books with the attestation pair absent, which is the honest audit row.
+     */
+    cancellationPolicy?(signal?: AbortSignal): Promise<EverfurResult<TelevetCancellationPolicy | null>>;
+    /** Clinicians licensed in a STATE. `state` is required by the route, not a filter: there is no unfiltered roster. */
+    clinicians?(state: string, signal?: AbortSignal): Promise<EverfurResult<readonly TelevetClinician[]>>;
+    /** This clinician's whole offered window. Never paginated: the range is server-owned and takes no cursor. */
+    slots(clinicianId: string, signal?: AbortSignal): Promise<EverfurResult<readonly TelevetSlot[]>>;
+    /** The soonest opening across ALL clinicians, or null. Powers the no-slots state and nothing else. */
+    nextSlot?(signal?: AbortSignal): Promise<EverfurResult<TelevetSlot | null>>;
+    /** Take the slot. The server requires a hold before a booking or a reschedule; it is what resolves the race. */
+    holdSlot(slotId: string): Promise<EverfurResult<TelevetSlotHold>>;
+    /**
+     * Create the consult.
+     *
+     * `idempotencyKey` is the IDENTITY of this booking, derived once from the held slot when the draft is
+     * composed. It seeds the header the funnel writes, so a resubmit after a timeout is the same booking and
+     * cannot create a second consult. It is not itself the header: see `book` in the factory below.
+     */
+    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;
+    /** The partner's `EverfurConfig.errorPolicy`. It can only narrow what the funnel already allows. */
+    readonly errorPolicy?: ErrorPolicyPort;
+    readonly telemetry?: TelemetryPort;
+    /** Injected in tests. Built from `auth` when absent. */
+    readonly funnel?: RequestFunnel;
+}
+/**
+ * Validate the booking body against the server's own bounds, BEFORE it is sent.
+ *
+ * The consumer app does this in its reducer (`canConfirm`) and again in its schema; the SDK does it here, in
+ * the layer that owns the wire, so a host that drives the controller directly gets the same refusal a screen
+ * does rather than a 422 halfway through.
+ *
+ * THE ATTESTATION PAIR IS CHECKED HERE RATHER THAN LEFT TO THE SERVER because a half pair is the one refusal
+ * the owner cannot act on. Every other rule above names something they can fix (pick a pet, write a reason);
+ * a 422 for "you sent the tick without the terms version" is a client bug wearing a booking failure, and it
+ * arrives after they pressed Confirm. Refusing locally keeps it a programming error, where it belongs.
+ */
+declare function validateBookingBody(body: TelevetBookingBody): string | null;
+declare function createTelevetBookingController(deps: TelevetBookingControllerDeps): Required<TelevetBookingController>;
+
+/**
+ * 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.
+ */
+declare const TELEVET_BOOKING_STEPS: readonly TelevetBookingStep[];
+interface TelevetBookingDraft {
+    readonly petId: string | null;
+    /** Two letters, re-confirmed on EVERY booking: the server pattern demands it. */
+    readonly state: string | null;
+    readonly clinicianId: string | null;
+    /** The held slot. A hold has no id of its own on this wire. */
+    readonly slot: TelevetSlot | null;
+    readonly holdExpiresAt: string | null;
+    /** The consent tick that mints a records grant in the booking transaction. */
+    readonly shareHealthRecords: boolean;
+    /**
+     * Minted ONCE per composed booking and reused across retries.
+     *
+     * Derived from the SLOT rather than a hold id, which this wire does not have. A timeout followed by a retry
+     * must not create a second consult.
+     */
+    readonly idempotencyKey: string | null;
+}
+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;
+    readonly draft: TelevetBookingDraft;
+    /** The furthest step reached, so the rail never appears to go backwards. */
+    readonly furthestIndex: number;
+}
+/**
+ * The starting state, OPENED ON THE FIRST VISIBLE STEP.
+ *
+ * Index 0 is `pet`, which a one-pet household skips, so starting there opens the flow on a screen that renders
+ * nothing and never advances. The skip rule must be applied at every place an index is chosen, not only when
+ * stepping.
+ *
+ * `ctx` is required rather than optional: an initial state that does not know the household size cannot know
+ * where to start. The seeded draft matters too - a host that seeds `state` (and, for a one-pet household,
+ * `petId`) must open PAST both of those steps.
+ */
+declare function initialTelevetBookingState(ctx: TelevetBookingContext, seed?: Partial<TelevetBookingDraft>): TelevetBookingState;
+type TelevetBookingAction = {
+    readonly type: 'patch';
+    readonly patch: Partial<TelevetBookingDraft>;
+} | {
+    readonly type: 'next';
+} | {
+    readonly type: 'back';
+} | {
+    readonly type: 'goTo';
+    readonly step: TelevetBookingStep;
+};
+/**
+ * Whether a step is skipped for STRUCTURAL reasons rather than user choice.
+ *
+ * NO DRAFT PARAMETER. The consumer's version takes one because an earlier shape skipped a `state` step once
+ * the draft held a code; that step is gone, so a parameter nothing reads would only invite a future skip rule
+ * that depends on draft contents without the attestation that made the old one safe.
+ *
+ * A skipped step must still have its value SET. The worst defect a flow of this shape can carry is skipping
+ * the pet picker for a one-pet household and never writing `petId`, which dead-ends the majority case; the
+ * flow seeds it instead.
+ */
+declare function isSkipped(step: TelevetBookingStep, ctx: TelevetBookingContext): boolean;
+/**
+ * Is there a visible step behind this one?
+ *
+ * EXPORTED because a host deciding with `state.index > 0` is answering a different question: a one-pet
+ * household starts at index 1 (its `pet` step is skipped), so that test says "yes" on the FIRST screen and
+ * produces a Back that dispatches, finds nothing behind it, and leaves the index unchanged - a dead press.
+ */
+declare function hasPreviousStep(state: {
+    readonly index: number;
+}, ctx: TelevetBookingContext): boolean;
+declare function televetBookingReducer(state: TelevetBookingState, action: TelevetBookingAction, ctx: TelevetBookingContext): TelevetBookingState;
+/** The step currently on screen. */
+declare function currentStep(state: TelevetBookingState): TelevetBookingStep;
+/**
+ * Is the draft complete enough to book?
+ *
+ * Mirrors the wire's own required fields, so an incomplete draft fails HERE rather than as a 422 after the
+ * owner presses Confirm.
+ */
+declare function canConfirm(draft: TelevetBookingDraft, reasonText: string): boolean;
+/**
+ * Has the hold expired?
+ *
+ * `nowMs` is INJECTED so the screen, the countdown and the confirm all answer to one clock rather than three
+ * calls to `Date.now()`.
+ */
+declare function isHoldExpired(draft: TelevetBookingDraft, nowMs: number): boolean;
+/**
+ * The idempotency key for a composed booking, derived from the SLOT.
+ *
+ * One definition, because the reducer clears it and the flow mints it: two spellings would let a retry after a
+ * cleared draft create a second consult.
+ */
+declare function televetBookingKey(slotId: string): string;
+/**
+ * The attestation half of the booking body: both fields, or nothing.
+ *
+ * ONE DEFINITION FOR BOTH PLATFORMS, and it lives here rather than in either container, because "did the owner
+ * attest" is a view DECISION made from the same three inputs on RN and on web, and two spellings of a bound
+ * pair is how one of them ships a 422. The server refuses exactly one of the two
+ * (`_attestation_evidence_is_whole`), so this returns a whole pair or an empty object and never a half.
+ *
+ * THREE CONDITIONS, ALL REQUIRED, and each one is a distinct fact rather than a redundant check:
+ *   - `stateAttested`  the owner ticked the jurisdiction. Evidence.
+ *   - `termsAttested`  the owner ticked the terms they were shown. Evidence.
+ *   - `policy`         terms with a SERVED version token were actually on screen. Without it there is nothing
+ *                      to name, and naming the wrong token is a typed 409 or, worse, an audit row that cites
+ *                      terms nobody presented.
+ *
+ * An owner shown no terms row has nothing to tick and books with the pair absent, which is exactly the
+ * compatibility case the server's optional fields exist for.
+ */
+declare function attestation(stateAttested: boolean, termsAttested: boolean, policy: {
+    readonly version: string;
+} | null | undefined): {
+    readonly state_attested: true;
+    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. */
+    readonly enabled: boolean;
+    readonly data: T | null;
+    readonly isPending: boolean;
+    readonly isError: boolean;
+    readonly error: EverfurError | null;
+    refetch(): void;
+}
+/** One write, in the shape the ported screens branch on. */
+interface TelevetWrite<Args extends readonly unknown[], T> {
+    readonly isPending: boolean;
+    /** The argument of the in-flight call, so a grid can mark the one row it is acting on. Null when idle. */
+    readonly variables: Args[0] | null;
+    mutate(...args: [...Args, {
+        readonly onSuccess?: (value: T) => void;
+        readonly onError?: (error: EverfurError) => void;
+    }?]): void;
+}
+/**
+ * The booking controller for the current scope: the injected one, or one built from the provider's session.
+ *
+ * `scopeEpoch` is a real dependency, exactly as it is for `useVetVisit`: an anonymous logout changes no
+ * identity string but rotates the session, and a controller that kept the previous session's auth would book a
+ * visit for the previous user.
+ */
+declare function useTelevetBookingController(injected?: TelevetBookingController): TelevetBookingController | null;
+/**
+ * True only when the server grants `televet` AND the provider is scoped to a user.
+ *
+ * The same predicate `useVetVisit` uses, so the button and the in-app flow cannot disagree about whether this
+ * member can have a visit at all.
+ */
+declare function useTelevetBookingAvailable(): {
+    readonly available: boolean;
+    readonly isPending: boolean;
+};
+/** What this US state permits. Disabled until a well-formed two-letter code is known. */
+declare function useTelevetStatePolicy(state: string | null, controller: TelevetBookingController | null): TelevetRead<TelevetStatePolicy>;
+/**
+ * Whether this member's plan covers a video visit.
+ *
+ * UNCONDITIONAL AND PARAMETERLESS, so it starts in parallel with the state policy rather than after it.
+ * Gating it behind a step or a chosen state would recreate the waterfall the gate exists to remove: the answer
+ * does not depend on anything the owner has filled in yet.
+ */
+declare function useTelevetBookingEntitlement(controller: TelevetBookingController | null): TelevetRead<{
+    readonly active: boolean;
+}>;
+/**
+ * The cancellation terms and their version token.
+ *
+ * UNCONDITIONAL, like the entitlement: the terms do not depend on the state, the vet or the slot, and the
+ * review screen needs them the moment it renders. Reading them on entry to the review step would show the
+ * owner a Confirm button whose terms row appears a beat later.
+ *
+ * A CONTROLLER WITHOUT THE METHOD reads as no terms, which is the same deliberate off-state a dark route
+ * produces: the tick is omitted and the booking sends the attestation pair absent, rather than a tick the
+ * SDK could not report.
+ */
+declare function useTelevetCancellationPolicy(controller: TelevetBookingController | null): TelevetRead<TelevetCancellationPolicy | null>;
+/** Clinicians licensed in a STATE. `state` is the route's required parameter, not a filter. */
+declare function useTelevetClinicians(state: string | null, controller: TelevetBookingController | null): TelevetRead<readonly TelevetClinician[]>;
+/** This clinician's whole offered window. Disabled until one is chosen. */
+declare function useTelevetSlots(clinicianId: string | null, controller: TelevetBookingController | null): TelevetRead<readonly TelevetSlot[]>;
+/**
+ * The soonest opening across ALL clinicians, for the no-slots state only.
+ *
+ * Read UNCONDITIONALLY rather than lazily on the empty case: it is a cheap cross-clinician lookup, and
+ * fetching it only after discovering the grid is empty would make the useful half of that state arrive a
+ * round-trip after the disappointing half.
+ */
+declare function useTelevetNextSlot(controller: TelevetBookingController | null): TelevetRead<TelevetSlot | null>;
+/** Take the slot. The server requires a hold before a booking or a reschedule. */
+declare function useTelevetHoldSlot(controller: TelevetBookingController | null): TelevetWrite<[slotId: string], TelevetSlotHold>;
+/** Create the consult. */
+declare function useTelevetBookConsult(controller: TelevetBookingController | null): TelevetWrite<[body: TelevetBookingBody, idempotencyKey: string], TelevetConsult>;
+/** 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. */
+{
+    readonly kind: 'emergency';
+    readonly categories: readonly string[];
+}
+/** No live paid subscription (402). Deterministic: never invite a retry. */
+ | {
+    readonly kind: 'not_entitled';
+}
+/** The slot went, or the hold lapsed. Re-fetch the grid. */
+ | {
+    readonly kind: 'slot_taken';
+}
+/** That clinician cannot host this consult. Pick another; a different TIME refuses again. */
+ | {
+    readonly kind: 'clinician_unavailable';
+}
+/**
+ * Too many attempts. Distinct from `failed` because the remedy is WAITING, and `failed` invites an immediate
+ * retry that fails again and, on a fixed window, can push the reset further out. Carries the server's own
+ * wait hint when it sends one.
+ */
+ | {
+    readonly kind: 'rate_limited';
+    readonly retryAfterSeconds: number | null;
+    /**
+     * The SERVER'S OWN wording, when it sends any.
+     *
+     * Carried rather than replaced with a string written here: a wait message is the server's to phrase, it
+     * can change without an app release, and this SDK does not author user-facing copy. Null renders no line
+     * at all rather than a placeholder.
+     */
+    readonly message: string | null;
+}
+/**
+ * The partner booking surface is not served for this tenant (404), so no request on it can succeed.
+ *
+ * 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 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';
+}
+/** Anything else, including a transport failure. A retry is reasonable. */
+ | {
+    readonly kind: 'failed';
+};
+declare function televetBookingRefusal(error: EverfurError): TelevetBookingRefusal;
+
+/** The platform-fixed consult length. */
+declare const CONSULT_MINUTES = 10;
+/**
+ * "9:20 PM - 9:30 PM EDT", the visit's bracket, zone-qualified.
+ *
+ * THE END TIME IS DERIVED, not served: a consult response carries `scheduled_at` only, and the platform fixes
+ * the consult at `CONSULT_MINUTES`. Falls back to the bare bracket when the zone cannot be named.
+ */
+declare function formatVisitRange(iso: string): string;
+/** "August 20, 9:20 PM EDT". */
+declare function formatWhen(iso: string): string;
+/**
+ * "Wed, August 20, 9:20 PM EDT". The booking confirmation only.
+ *
+ * The weekday is computed from the SAME instant in the SAME zone as the clock beside it, so the two cannot
+ * disagree.
+ */
+declare function formatWhenWithDay(iso: string): string;
+
+declare const TELEVET_BOOKING_COPY: Readonly<{
+    stateBlockedTitle: string;
+    noCliniciansTitle: string;
+    /** 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". */
+    reviewsLabel: string;
+    rescheduleFromTemplate: string;
+    rescheduleFailed: string;
+    keepExistingCta: string;
+    bookingPausedTitle: string;
+    slotsErrorTitle: string;
+    noSlotsTitle: string;
+    /** The cross-clinician next opening, shown UNDER `noSlotsTitle`. `{when}` is DATA. */
+    nextOpeningTemplate: string;
+    /** The row that acts on it. Returns the owner to the clinician step. */
+    seeOtherVetsCta: string;
+    retryCta: string;
+    /** The hold lapsed while the owner was on a later step. */
+    holdExpired: string;
+    slotTaken: string;
+    reasonPlaceholder: string;
+    reasonTooLong: string;
+    /** Default OFF: sharing a pet's medical history is opt-in, and it is revocable afterwards. */
+    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;
+    close: string;
+    continueCta: string;
+    petSelectTitle: string;
+    addPetCta: string;
+    locationUnknownTitle: string;
+    locationUnknownBody: string;
+    locationUnknownCta: string;
+    locationBlockedTitle: string;
+    locationBlockedBody: string;
+    locationBlockedCta: string;
+    /** A real coordinate the host could not name. Retrying will not help. */
+    locationUnavailableTitle: string;
+    locationUnavailableBody: string;
+    stateAttestTemplate: string;
+    describeHeading: string;
+    describeHelpLong: string;
+    addPhotoCta: string;
+    removePhotoLabel: string;
+    summaryPet: string;
+    summaryVet: string;
+    summaryWhen: string;
+    summaryLength: string;
+    summaryReason: string;
+    /** "10 minutes" as a DERIVED fact: `{n}` is filled from `CONSULT_MINUTES` so the two cannot drift. */
+    summaryLengthTemplate: string;
+    confirmCta: string;
+    bookedTitle: string;
+    addToCalendarCta: string;
+    doneCta: string;
+    /** The confirmation's three steps. `{pet}` is DATA. */
+    booked: Readonly<{
+        remindPromise: string;
+        summaryPromise: string;
+        joinPromise: string;
+        backToPet: string;
+        calendarAdded: string;
+        calendarFailedBody: string;
+    }>;
+    /**
+     * THE FLOW CHROME, not a step: the shell every step renders inside, the discard guard, the hint on Close,
+     * and the states shown before any step screen has something to draw.
+     *
+     * `navTitle` and `close` are deliberately NOT duplicated here. The chrome reads the keys the flow already
+     * owns, so approving the bar's wording is one edit, not two that can drift apart.
+     */
+    chrome: Readonly<{
+        /** Announced after "Close", so a screen reader hears what the press costs. */
+        closeHint: string;
+        discardTitle: string;
+        discardBody: string;
+        discardConfirmCta: string;
+        discardKeepCta: string;
+        noPetsTitle: string;
+        loadFailedTitle: string;
+        retryCta: string;
+    }>;
+    /**
+     * The emergency refusal. This is the one screen on the surface that interrupts.
+     *
+     * 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<{
+        title: string;
+    }>;
+    /**
+     * THE SPOKEN NAME OF EACH LOADING REGION, AND THE SPOKEN POSITION OF THE STEP RAIL.
+     *
+     * ── WHY THESE EXIST AT ALL ───────────────────────────────────────────────────────────────────────────
+     * Each booking step renders its wait as a `role="progressbar"` container of grey blocks. The blocks are
+     * `aria-hidden` (a reader announcing eight rectangles is noise), so the CONTAINER's accessible name is the
+     * only thing a screen-reader user is told while the step is loading. Six of these containers shipped with
+     * no name at all, which a reader announces as an unnamed busy region: the user hears that something is
+     * happening and nothing about what. The records port established the convention this fixes
+     * (`DASHBOARD_COPY.loading`, `REQUEST_SCREEN_COPY.loading`, `DEPTH_COPY.loadingTimeline`,
+     * `CLINIC_PICKER_COPY.loading`, `SHARE_COPY.loadingLinks`): the name is an `aria-label` sourced from a
+     * copy module, phrased as what is being loaded.
+     *
+     * ── THESE WERE BRACKETED PLACEHOLDERS, AND THEY ARE NOT ANY MORE. WHAT CHANGED IS THE SOURCE ─────────
+     * The previous round wrote `[PLACEHOLDER: ...]` here on the reasoning that the consumer booking deck has
+     * no loading strings, so there was nothing to port and inventing the words would be this SDK authoring
+     * product voice for a partner's customers. The first half of that was simply not measured: the CONSUMER
+     * WEB APP has carried both of these strings for months, and the round that bracketed these keys looked at
+     * the React Native deck rather than at the web app this surface is a port OF.
+     *
+     *   `everfur-frontend app/product/televet/components/SystemStates.tsx:46`
+     *     `const LOADING_LABEL_COPY = 'Loading. Nothing to read yet.';`
+     *   and its own docblock, verbatim: "The written line says that this region is fetching and has nothing
+     *   to read yet, and it NAMES NO SCREEN, because the default is rendered on five different ones. A caller
+     *   that knows its surface should pass `label` instead, which is a one-line change at each call site and
+     *   the reason the prop exists."
+     *
+     *   `everfur-frontend app/product/see-a-vet/copy.ts:194`
+     *     `progressLabel: (step: number, total: number) => `Step ${step} of ${total}``
+     *
+     * So the convention the consumer settled is: ONE written sentence for the generic busy region, and a
+     * per-surface name where the caller knows its surface. That is what this block now is. Each name is the
+     * consumer's own sentence with the surface named, in the consumer's own grammar.
+     *
+     * ── WHY AUTHORING THESE IS IN SCOPE AND AUTHORING THE REST IS NOT ────────────────────────────────────
+     * The consumer copy deck draws this exact fence around this exact category, and the wording is worth
+     * quoting because it is the licence under which these five keys are written
+     * (`everfur-frontend app/product/see-a-vet/copy.ts:185-189`):
+     *
+     *   "assistive-technology labels: the narrowest category of string it is defensible for an engineer to
+     *    author, and none of them makes a clinical, urgency or prescribing claim. They still want review
+     *    before this page is armed."
+     *
+     * Every value below is a functional name for a region or a position. None names a product, makes a
+     * clinical or urgency claim, promises a time, or says anything an owner could act on wrongly. They are
+     * what a screen reader says INSTEAD OF SILENCE. The rest of this deck stays draft-ported and the ship
+     * gate below still holds it, because a marketing or clinical sentence is a different category and this
+     * fence is the reason the two can be told apart.
+     */
+    loading: Readonly<{
+        /**
+         * The pet step's roster read.
+         *
+         * "Pets" and not "Your pets": the host supplies the account, and on a partner's multi-pet dashboard the
+         * surface may be mounted for a household rather than for one person. The consumer's own default names
+         * no owner for the same reason it names no screen.
+         */
+        pets: "Loading pets. Nothing to read yet.";
+        /** The clinician step's roster read. "Vets", the word every consumer frame uses for this list. */
+        clinicians: "Loading vets. Nothing to read yet.";
+        /**
+         * The slot step's availability read, and the reschedule screen's own slot read.
+         *
+         * "Times" rather than "availability" or "slots": `3668:5240` is headed "Pick a date and time", so this
+         * is the word the owner has just read on the screen the wait belongs to.
+         */
+        slots: "Loading times. Nothing to read yet.";
+        /** The reschedule screen waiting for the consult it is moving. "Visit", as `visit.title` already says. */
+        consult: "Loading your visit. Nothing to read yet.";
+        /**
+         * THE STEP RAIL'S SPOKEN POSITION, and it is a TEMPLATE rather than a name, because the consumer does
+         * not name this region at all.
+         *
+         * `FunnelProgress` (`everfur-frontend app/product/televet/components/BookingFunnel.tsx:126-141`) draws
+         * the rail as `aria-hidden` bars beside ONE `sr-only` paragraph reading
+         * `intakeSystemCopy.progressLabel(current, total)`, and its docblock states the rule: "It is a labelled
+         * group, not decoration: the position is stated in text for assistive technology, in the intake's own
+         * words, and the bars are `aria-hidden` so nothing reads eight empty items after it."
+         *
+         * A `progressbar` with a value and a region NAME is a different announcement from the consumer's: the
+         * reader says the name, then "4 of 6", which is two utterances for one fact and neither of them is the
+         * sentence the consumer app says. So the web chrome now carries the consumer's sentence, filled with the
+         * step and the total, and `{step}` / `{total}` are DATA through `fill`.
+         */
+        progressTemplate: "Step {step} of {total}";
+    }>;
+}>;
+type TelevetBookingCopy = typeof TELEVET_BOOKING_COPY;
+/**
+ * THE SHIP GATE. False while the deck is unapproved OR any value is still a bracketed placeholder, so a
+ * partial approval cannot half-ship. Deliberately blunt: the failure it prevents is a partner's user reading
+ * a string Everfur drafted for its own app and never signed off for someone else's.
+ *
+ * BOTH CONDITIONS ARE STILL CHECKED EVEN THOUGH ONE OF THEM NOW HAS NOTHING TO FIND. The placeholder scan
+ * finds no placeholder in the deck today, which is the point of the accessibility names having landed; it
+ * stays because the next string added here is as likely to be a bracket as not, and a gate deleted once it
+ * passes is a gate that was never load-bearing. `TELEVET_BOOKING_COPY_APPROVED` is the condition holding the
+ * screens dark now, and its own note says why that is the honest answer rather than a leftover.
+ *
+ * THIS IS LOAD-BEARING, not advisory. `EverfurTelevetBooking`, `EverfurTelevetReschedule` and
+ * `TelevetBookedScreen` each refuse to render their ported screens while it answers false, and hand over to
+ * the hosted visit instead. See `tests/component/televetCopyGate.test.tsx`, which mounts them and pins it.
+ */
+declare function isTelevetBookingCopyReady(): boolean;
+
+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 };