@everfur/sdk 0.1.1 → 0.4.0

package/dist/bookingCopy-SREvkG19.d.cts

@@ -0,0 +1,732 @@
+import { c as EverfurResult, E as EverfurError } from './EverfurResult-DN9pL2Ab.cjs';
+import { R as RequestFunnel } from './requestFunnel-BjDpqqvm.cjs';
+import { A as AuthContext } from './identity-C2-08BZW.cjs';
+import { E as ErrorPolicyPort } from './ErrorPolicyPort-CNf4uQZP.cjs';
+import { T as TelemetryPort } from './TelemetryPort-BDNr00hu.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;
+}
+/** 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;
+
+/** 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;
+/**
+ * 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 answers a policy with both facts false. */
+    statePolicy?(state: string, signal?: AbortSignal): Promise<EverfurResult<TelevetStatePolicy>>;
+    /** Whether this member's plan covers a video visit. A dark route answers `{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>>;
+}
+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>;
+
+type TelevetBookingStep = 'pet' | '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;
+}
+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>;
+
+/** 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>;
+
+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 the remedy there is the hosted handoff rather than any
+ * retry. 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;
+    /** 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;
+    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.
+     *
+     * 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.
+     */
+    emergency: Readonly<{
+        bannerTitle: string;
+        keepBookingCta: string;
+        lede: 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 { 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 };