@everfur/sdk 0.3.0 → 0.5.0

package/dist/web/televet/booking/index.d.ts

@@ -0,0 +1,770 @@
+import { ReactNode, CSSProperties } from 'react';
+import { P as PetRef } from '../../../ids-B2GAAifq.js';
+export { B as Brand, _ as __brand } from '../../../ids-B2GAAifq.js';
+import { c as TelevetConsult, d as TelevetBookingStep, e as TelevetBookingController, f as TelevetTriageRead, g as TelevetStateInterestWrite, T as TelevetEmptyRosterCause, a as TelevetStateInterestAction$1, b as TelevetMediaShortfall, i as TelevetSlot } from '../../../bookingCopy-CJir9mjb.js';
+export { C as CANCELLATION_POLICY_VERSION_MAX, j as CANCEL_REASON_MAX, k as CONSULT_KINDS, l as CONSULT_MINUTES, m as CONSULT_STATUSES, n as ConsultKind, o as ConsultStatus, M as MEDIA_REFS_MAX, N as NO_MEDIA_SHORTFALL, R as REASON_TEXT_MAX, p as TELEVET_BOOKING_BASE, q as TELEVET_BOOKING_COPY, r as TELEVET_BOOKING_STEPS, s as TELEVET_CONSULT_PAGE_LIMIT, t as TELEVET_JOIN_CLOSES_MINUTES_AFTER, u as TELEVET_JOIN_OPENS_MINUTES_BEFORE, v as TERMINAL_CONSULT_STATUSES, w as TelevetBookingAction, x as TelevetBookingBody, y as TelevetBookingContext, z as TelevetBookingControllerDeps, A as TelevetBookingCopy, B as TelevetBookingDraft, D as TelevetBookingEntitlement, E as TelevetBookingFailure, F as TelevetBookingRefusal, G as TelevetBookingState, h as TelevetCancelReceipt, H as TelevetCancellationPolicy, I as TelevetClinician, J as TelevetEarlyTriage, K as TelevetEmptyRosterView, aH as TelevetJoinBlock, aI as TelevetJoinDecision, O as TelevetJoinState, P as TelevetMediaRefusal, Q as TelevetRead, S as TelevetSlotHold, U as TelevetStateInterestReason, V as TelevetStatePolicy, W as TelevetTriageVerdict, X as TelevetWrite, Y as attestation, Z as canConfirm, _ as canManageTelevetVisit, $ as createTelevetBookingController, a0 as currentStep, a1 as emptyTelevetDraft, a2 as formatVisitRange, a3 as formatWhen, a4 as formatWhenWithDay, a5 as hasPreviousStep, a6 as initialTelevetBookingState, a7 as isHoldExpired, a8 as isMediaShortfallEmpty, a9 as isSkipped, aa as isTelevetBookingCopyReady, ab as isWellFormedStateCode, ac as mediaShortfallFromUnsentPicks, ad as splitTelevetVisits, ae as televetBookingKey, af as televetBookingReducer, ag as televetBookingRefusal, ah as televetCancelCall, ai as televetConsultCall, aj as televetEmptyRosterCause, ak as televetEmptyRosterView, al as televetHoldCall, am as televetJoinCall, aJ as televetJoinDecision, an as televetJoinOpensAtMs, ap as televetMediaShortfallLines, aq as televetRescheduleCall, ar as useEarlyTriage, as as useStateInterest, at as useTelevetBookConsult, au as useTelevetBookingAvailable, av as useTelevetBookingController, aw as useTelevetBookingEntitlement, ax as useTelevetCancellationPolicy, ay as useTelevetClinicians, az as useTelevetHoldSlot, aA as useTelevetJoin, aB as useTelevetNextSlot, aC as useTelevetRescheduleConsult, aD as useTelevetSlots, aE as useTelevetStatePolicy, aF as validateBookingBody, aG as withUnsentPicks } from '../../../bookingCopy-CJir9mjb.js';
+import { V as VetVisitIntent } from '../../../visitIntent-D7_yVp1I.js';
+import { E as EverfurTelevetFlowRequest } from '../../../televetGlobal-Cs9Wbqsy.js';
+import { E as EverfurTheme } from '../../../tokens-CIngRkvt.js';
+export { b as VetCallCredential, c as VetCallJoinRefusal, d as VetCallLimits, p as parseVetCallCredential, v as vetCallJoinReason, e as vetCallJoinRefusal } from '../../../callRoom-7wrE3RP2.js';
+export { E as EverfurError, a as EverfurErrorCategory, b as EverfurErrorCode } from '../../../EverfurError-DmELDpXp.js';
+export { E as EverfurResult } from '../../../EverfurResult-SGvHKsCB.js';
+export { W as WidgetPet } from '../../../petsRepository-BjKJ8UsN.js';
+import '../../../requestFunnel-D7ipek3e.js';
+import '../../../ErrorPolicyPort-D22LUVrK.js';
+import '../../../config-ClI7QxB0.js';
+import '../../../identity-CLAUq-K4.js';
+import '../../../TelemetryPort-BDNr00hu.js';
+import '../../../profile-CSs1wlXT.js';
+
+/** The calendar entry a booked visit asks the host to write. */
+interface TelevetCalendarEvent {
+    /**
+     * A stable key for THIS consult's entry.
+     *
+     * Keyed on the CONSULT so a re-press updates the same entry rather than writing a second event for one
+     * visit, and so a later cancel or reschedule can address the SAME row. A host that ignores the key writes
+     * duplicates the owner has to clean up by hand.
+     */
+    readonly key: string;
+    readonly title: string;
+    readonly startDate: Date;
+    readonly endDate: Date;
+    /** The reminder offset in minutes, negative for "before". The platform queues its own at the same offset. */
+    readonly alarmOffsetMinutes: number;
+}
+/** Writes the entry. Resolves true when it landed; false when the host has no calendar to write to. */
+type TelevetCalendarWriter = (event: TelevetCalendarEvent) => Promise<boolean>;
+/** The calendar key for a consult. One definition, so a cancel and a reschedule address the booked row. */
+declare function televetConsultCalendarKey(consultId: string): string;
+interface TelevetBookedScreenProps {
+    readonly consult: TelevetConsult;
+    readonly petName: string | null;
+    readonly onDone: () => void;
+    /** Absent, there is no Add to calendar control. */
+    readonly onAddToCalendar?: TelevetCalendarWriter | undefined;
+    /**
+     * Has the host PROVEN it can host the call in place? Defaults to false.
+     *
+     * Fail closed: a host that has not said so is assumed not to have mounted the call surface, and the in-place
+     * join promise is withheld rather than printed on a hope.
+     */
+    readonly canJoinInApp?: boolean;
+}
+declare function TelevetBookedScreen({ consult, petName, onDone, onAddToCalendar, canJoinInApp, }: TelevetBookedScreenProps): ReactNode;
+
+/** The heading levels the DOM has elements for. */
+type EverfurHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+
+/**
+ * The host's own discard confirmation.
+ *
+ * Receives the ported title, body and the two button labels, and resolves true to leave. A partner with its
+ * own dialog system passes this; absent, the SDK renders the in-page dialog below.
+ */
+type TelevetDiscardConfirm = (prompt: {
+    readonly title: string;
+    readonly body: string;
+    readonly confirmLabel: string;
+    readonly keepLabel: string;
+}) => Promise<boolean>;
+interface TelevetBookingChromeProps {
+    readonly step: TelevetBookingStep;
+    readonly furthestIndex: number;
+    /** The title on the bar. The reschedule flow passes its own, so the bar never says "Book a visit" there. */
+    readonly title?: string;
+    /** False on the first visible step, where Back would leave the flow entirely. */
+    readonly canGoBack: boolean;
+    /**
+     * Has the owner entered anything worth losing?
+     *
+     * Gates the discard confirm AND the `beforeunload` backstop. A confirm on an untouched flow is a pointless
+     * obstacle; NO confirm on a flow holding typed clinical text is the actual defect, because that text is
+     * volatile component state with no draft to restore it from.
+     */
+    readonly isDirty: boolean;
+    readonly onBack: () => void;
+    readonly onClose: () => void;
+    readonly onConfirmDiscard?: TelevetDiscardConfirm | undefined;
+    /**
+     * The heading level of the bar's title. Defaults to 2, the level an embedded surface may safely claim.
+     *
+     * Pass 1 only when the flow IS the page in your app. See `src/web/headingLevel.ts`.
+     */
+    readonly headingLevel?: EverfurHeadingLevel | undefined;
+    /**
+     * Is the emergency warning up in place of Describe? The web funnel counts it as its own step (`Desktop - 18`,
+     * fourth of eight), so the bar lights four segments while it is on screen.
+     */
+    readonly triageOpen?: boolean | undefined;
+}
+declare function TelevetBookingChrome({ step, furthestIndex, title, canGoBack, isDirty, onBack, onClose, onConfirmDiscard, headingLevel: level, triageOpen, }: TelevetBookingChromeProps): ReactNode;
+/**
+ * The back control's spoken label.
+ *
+ * "Back" is the platform word for the control and is not product copy, which is why it is a constant here and
+ * not a key in the ported deck. The web records port declares the same constant for the same reason.
+ */
+declare const BACK_LABEL = "Back";
+
+/** The pet's own clinic, when the HOST holds it. The RN file's docblock explains why it is a prop. */
+interface TelevetPrimaryVet {
+    readonly detail?: string | null;
+    /** Places the call. Absent, the row is not a link and takes no click. */
+    readonly dial?: (() => void) | undefined;
+}
+interface TelevetEmergencyExitsProps {
+    /** The pet's name, for the primary-vet card. Absent, that card is not drawn. */
+    readonly petName?: string | null | undefined;
+    readonly primaryVet?: TelevetPrimaryVet | null | undefined;
+    /** The host's own emergency-vet locator. Absent, that card is not drawn. */
+    readonly onFindEmergencyVet?: (() => void) | undefined;
+    /** Distinguishes the two places the warning is drawn, for tests. */
+    readonly testIDPrefix: string;
+}
+declare function TelevetEmergencyExits({ petName, primaryVet, onFindEmergencyVet, testIDPrefix, }: TelevetEmergencyExitsProps): ReactNode;
+
+/** A picked-but-not-yet-uploaded attachment, in the host's own terms. */
+interface TelevetIntakeMediaItem {
+    readonly uri: string;
+    readonly filename: string;
+    readonly mimeType: string;
+    readonly fileSize: number;
+}
+/**
+ * The host's media picker.
+ *
+ * Resolves the picks, or null when the owner cancelled. The SDK takes no picker dependency and opens no file
+ * dialog of its own; a partner supplies whichever picker its site already has, typically an `<input
+ * type="file">` whose `File` objects it turns into object URLs.
+ *
+ * `limit` is the remaining headroom, so the host can cap its own selection rather than returning picks this
+ * row has to silently discard.
+ */
+type TelevetMediaPicker = (limit: number) => Promise<readonly TelevetIntakeMediaItem[] | null>;
+interface TelevetIntakeMediaProps {
+    readonly media: readonly TelevetIntakeMediaItem[];
+    readonly onChange: (next: readonly TelevetIntakeMediaItem[]) => void;
+    /** Absent, the row renders nothing at all. There is no disabled Add control. */
+    readonly onPickMedia?: TelevetMediaPicker | undefined;
+    /**
+     * The list's accessible name.
+     *
+     * Required, with no default string here: naming the group is what makes the tiles announce as a set, and
+     * the name is user-facing copy this SDK does not author. The intake step passes a ported key down.
+     */
+    readonly listLabel: string;
+}
+declare function TelevetIntakeMedia({ media, onChange, onPickMedia, listLabel }: TelevetIntakeMediaProps): ReactNode;
+
+/** What the host can tell us about a location it could not resolve, so the right card renders. */
+type TelevetLocationStatus = 'unknown' | 'blocked' | 'unavailable';
+interface EverfurTelevetBookingProps {
+    /** The pet the visit is for. Seeds the draft; a one-pet roster skips the picker entirely. */
+    readonly petRef?: PetRef | null;
+    /** The owner's two-letter US state. The SDK never reads a browser location for it. */
+    readonly usState?: string | null;
+    /** Host/test seam: inject a booking controller instead of building one from the provider's session. */
+    readonly controller?: TelevetBookingController;
+    readonly onBooked?: (consult: TelevetConsult) => void;
+    /** Leaves the flow. The flow never navigates itself, so the same screens work in a modal, a tab or a route. */
+    readonly onExit?: () => void;
+    /** Leaves the flow to create a pet, then comes back. Absent, the empty roster has no action. */
+    readonly onAddPet?: () => void;
+    /** The host's media picker for the intake step. Absent, there is no attachment row. */
+    readonly onPickMedia?: TelevetMediaPicker;
+    /** The host's calendar writer for the confirmation. Absent, there is no Add to calendar control. */
+    readonly onAddToCalendar?: TelevetCalendarWriter;
+    /** The host's own discard dialog. Absent, the SDK renders its own `<dialog>`. */
+    readonly onConfirmDiscard?: TelevetDiscardConfirm;
+    /** Asks the host to resolve the owner's state again. Absent, the location cards render without an action. */
+    readonly onRequestLocation?: () => void;
+    /** Why the host has no state for us, so the right card renders. */
+    readonly locationStatus?: TelevetLocationStatus;
+    /**
+     * THE EMERGENCY TRIAGE READ, asked after Describe rather than only at Confirm.
+     *
+     * ABSENT MEANS NO EARLY QUESTION and the flow behaves as it did before, with the server's own
+     * `emergency_ack_required` refusal still waiting at Confirm. That is the consumer's rule for a triage read
+     * that could not answer, not a degraded mode.
+     *
+     * A SEAM BECAUSE `POST /widget/v1/televet/consults/triage` IS NOT SERVED (verified on EFBackend main
+     * 2026-09-22 against the partner_televet route decorators). The consumer WEB funnel does ask the question
+     * at this position (`continueFromDescribe`, since 2026-09-12) but against a CONSUMER session.
+     */
+    readonly onTriageReason?: TelevetTriageRead;
+    /**
+     * THE STATE-INTEREST WRITE: the one way out of "we have no vet licensed in your state".
+     *
+     * ABSENT MEANS THE CONTROL DOES NOT RENDER. `POST /widget/v1/televet/state-interest` does not exist on the
+     * partner plane, and the consumer WEB app already refused to ship this button over an unreachable write
+     * for the same reason on its own pre-signup funnel: "the button would 401 for every visitor who pressed
+     * it" (everfur-frontend StateUnavailableNotice.tsx:34-41).
+     */
+    readonly onStateInterest?: TelevetStateInterestWrite;
+    /**
+     * THE PET'S OWN CLINIC, for the emergency screen's one exit row. The partner wire has no primary-vet
+     * concept, so a host that holds its customer's clinic supplies it and gets the consumer's exact row.
+     */
+    readonly primaryVet?: TelevetPrimaryVet | null;
+    /**
+     * THE HOST'S OWN EMERGENCY-VET LOCATOR, for the emergency warning's "Find an emergency vet near you" card.
+     * The consumer web links its own clinic finder; the SDK has none and navigates the partner's page nowhere,
+     * so the card renders only when the host can take the member to one. Absent, the other cards still render.
+     */
+    readonly onFindEmergencyVet?: () => void;
+    /**
+     * Has the host PROVEN it can host the call in place? Defaults to false.
+     *
+     * Fail closed: without the call surface mounted the confirmation must not promise an in-place join.
+     */
+    readonly canJoinInApp?: boolean;
+    /**
+     * What to render when the partner booking surface is not served for this tenant.
+     *
+     * Absent, the paused card, inside the chrome whose Close is the way out. Nothing leaves the page by default;
+     * a host that wants the hosted visit offered here passes `() => <VetVisitButton prefer="redirect" />`.
+     */
+    readonly renderUnavailable?: () => ReactNode;
+    /**
+     * The heading level this flow's title claims. Defaults to 2.
+     *
+     * A DROP-IN WIDGET DOES NOT OWN YOUR PAGE'S `<h1>`, so the default is 2 and every heading inside the flow
+     * sits one level below it. Pass 1 when the flow IS the page in your app. See `src/web/headingLevel.ts` for
+     * the full reasoning and for why the default falls on the safe side rather than on the tidier one.
+     */
+    readonly headingLevel?: number;
+    readonly style?: CSSProperties;
+    readonly testID?: string;
+}
+
+declare function EverfurTelevetBooking(props: EverfurTelevetBookingProps): ReactNode;
+
+interface TelevetEarlyEmergencyProps {
+    readonly petName?: string | null;
+    readonly primaryVet?: TelevetPrimaryVet | null;
+    /** The host's own emergency-vet locator, for the "Find an emergency vet near you" card. */
+    readonly onFindEmergencyVet?: (() => void) | undefined;
+    readonly onContinue: () => void;
+}
+/**
+ * THE EMERGENCY WARNING, IN PLACE OF DESCRIBE. The clinical-safety surface on this flow.
+ *
+ * The consumer web app's interstitial (BookingFunnel.tsx:713-774): its heading, its body, its cards and its
+ * continue control, in the web deck's words. The mobile shape underneath (the two-point danger edge, the
+ * assertive region) is kept, because both apps interrupt the same way.
+ *
+ * ── THE DOM PIECES THAT CARRY WHAT THE RN PROPS CARRIED ─────────────────────────────────────────────────
+ * `role="alertdialog"` with `aria-modal` is deliberately NOT used. This is not an overlay: the container
+ * REPLACES the intake step with it, so there is no live form underneath for a modal to fence off, and
+ * claiming a modal that traps no focus is a worse lie than claiming none. What the screen needs instead is
+ * that its heading is announced the moment it mounts, which `role="alert"` on the region does, and that its
+ * heading is a real heading so a reader can jump to it.
+ *
+ * IT CANNOT BE SKIPPED PAST for the same three container-level reasons the RN file lists: it replaces the
+ * step, Back returns to the words without acknowledging, and the acknowledgement is bound to the exact text.
+ */
+declare function TelevetEarlyEmergency({ petName, primaryVet, onFindEmergencyVet, onContinue, }: TelevetEarlyEmergencyProps): ReactNode;
+interface TelevetStateInterestActionProps {
+    /** Null renders NOTHING: no seam, no control. */
+    readonly action: TelevetStateInterestAction$1 | null;
+    readonly testIDPrefix: string;
+}
+/**
+ * ASK TO BE TOLD WHEN THE FACT ON SCREEN CHANGES.
+ *
+ * PORTED FROM THE CONSUMER WEB APP (`StateInterestPanel.tsx:100-130`), which is the right reference for a DOM
+ * surface and differs from the phone in one visible way: the pending state is a LABEL
+ * (`stateInterestSubmitting`, ownerCopy.ts:524) rather than a spinner inside the button. The web app made
+ * that choice for its own surface and this follows it, so a partner's web page reads the way everfur.com does.
+ *
+ * THE FAILURE IS `role="alert"` AND THE JOIN IS `role="status"`, matching the consumer's `Notice` tones
+ * (danger/alert, success/status). A failed write needs to interrupt because the member is about to walk away
+ * believing they were added; a success can wait for a pause.
+ */
+declare function TelevetStateInterestAction({ action, testIDPrefix, }: TelevetStateInterestActionProps): ReactNode;
+interface TelevetClinicianEmptyStateProps {
+    readonly cause: TelevetEmptyRosterCause;
+    readonly onRetry?: (() => void) | undefined;
+    readonly stateInterest?: TelevetStateInterestAction$1 | null;
+}
+/**
+ * THE TERMINAL STATE FOR A RESOLVED, STATE-SCOPED EMPTY CLINICIAN ROSTER.
+ *
+ * Mobile shape in DOM: the consumer web funnel is pre-signup and reads no roster, so it has no equivalent.
+ * The retry follows the CAUSE rather than the screen, and the decision lives in
+ * `react/televet/clinicianEmptyState.ts` so this file and its RN sibling cannot disagree about which
+ * sentence is true.
+ */
+declare function TelevetClinicianEmptyState({ cause, onRetry, stateInterest, }: TelevetClinicianEmptyStateProps): ReactNode;
+interface TelevetEntitlementInterestStateProps {
+    /** Opens the state-scoped roster read and nothing else. Absent, the card stands alone. */
+    readonly onCheckAvailability?: (() => void) | undefined;
+}
+/** THE SUBSCRIPTION TRUTH WITH THE ONE DELIBERATELY NON-BOOKING ESCAPE HATCH. See the RN sibling's docblock. */
+declare function TelevetEntitlementInterestState({ onCheckAvailability, }: TelevetEntitlementInterestStateProps): ReactNode;
+interface TelevetMediaDropNoticeProps {
+    readonly shortfall: TelevetMediaShortfall;
+    readonly testIDPrefix: string;
+}
+/**
+ * WHAT HAPPENED TO THE OWNER'S ATTACHMENTS, one line per cause.
+ *
+ * Ported from the consumer web app's own composition: `consultAttachmentShortfallLines` builds the sentences
+ * (consultAttachmentUpload.ts:382-407) and `BookingMediaField.tsx:441` renders them as a list. So this is a
+ * `<ul>`, which is what the web app does and what a reader needs in order to be told how many things went
+ * wrong before it reads the first one.
+ *
+ * MOUNTED ON BOTH REVIEW AND THE CONFIRMATION, for the reason the consumer mobile app found the hard way:
+ * review unmounts the instant the booking succeeds, and the confirmation is where a "your photo did not reach
+ * the vet" line actually has to be read.
+ */
+declare function TelevetMediaDropNotice({ shortfall, testIDPrefix, }: TelevetMediaDropNoticeProps): ReactNode;
+
+/** The screens of the televet stack. */
+type TelevetScreen = 
+/** Where a vet entry lands: the visits when one is still ahead, otherwise the booking. The default root. */
+{
+    readonly name: 'home';
+} | {
+    readonly name: 'booking';
+}
+/** The member's visits, upcoming and past, each with its own Join, Reschedule and Cancel. */
+ | {
+    readonly name: 'visits';
+} | {
+    readonly name: 'reschedule';
+    readonly consult: TelevetConsult;
+}
+/** Mint the room credential for this consult and join it, behind the recording notice. */
+ | {
+    readonly name: 'call';
+    readonly consultId: string;
+    readonly clinicianName?: string | null | undefined;
+    readonly petName?: string | null | undefined;
+}
+/** A visit the member already has, as a tapped reminder names it. Opens the visits. */
+ | {
+    readonly name: 'visit';
+    readonly visitRef: string;
+    readonly intent: VetVisitIntent | null;
+};
+/**
+ * The screen a request opens on: the visit it names, or the landing (the visits when one is ahead, otherwise
+ * a new booking). What `EverfurTelevetHost` and a partner's own presenter both use, so the two cannot open the
+ * same request on different screens.
+ */
+declare function televetScreenForRequest(request: EverfurTelevetFlowRequest): TelevetScreen;
+/** How the flow's own stack relates to the browser's history. */
+type TelevetHistoryMode = 'memory' | 'browser';
+interface EverfurTelevetProps {
+    /** The pet the visit is for. Seeds the draft; a one-pet roster skips the picker entirely. */
+    readonly petRef?: PetRef | null;
+    /** The owner's two-letter US state. The SDK never reads a browser location for it. */
+    readonly usState?: string | null;
+    /** Host/test seam: inject a booking controller instead of building one from the provider's session. */
+    readonly controller?: TelevetBookingController;
+    readonly onBooked?: (consult: TelevetConsult) => void;
+    /** The root screen's exit; absent, the root's Close does nothing and the host owns leaving. */
+    readonly onExit?: () => void;
+    readonly onAddPet?: () => void;
+    readonly onPickMedia?: TelevetMediaPicker;
+    readonly onAddToCalendar?: TelevetCalendarWriter;
+    readonly onConfirmDiscard?: TelevetDiscardConfirm;
+    readonly onRequestLocation?: () => void;
+    readonly locationStatus?: TelevetLocationStatus;
+    /**
+     * THE PET'S OWN CLINIC, for the emergency screen's exit row. The partner wire has no primary-vet concept,
+     * so a host that holds its customer's clinic passes it here and gets the consumer's exact row.
+     */
+    readonly primaryVet?: TelevetPrimaryVet | null;
+    /**
+     * THE EMERGENCY SCREEN'S "Find an emergency vet near you" ROW. The SDK has no clinic directory and opens
+     * nothing outside the page, so the row renders only when the host can take the member to one of its own.
+     */
+    readonly onFindEmergencyVet?: () => void;
+    /**
+     * The emergency question asked after Describe. Absent, the question is asked at Confirm by the server, as
+     * it is today: the partner plane serves no triage route. See `EverfurTelevetBooking`.
+     */
+    readonly onTriageReason?: TelevetTriageRead;
+    /**
+     * How the flow's stack relates to the browser's history. `memory` by default, which never touches
+     * `history`: a widget embedded in someone else's page must not take over their back button.
+     */
+    readonly historyMode?: TelevetHistoryMode;
+    /**
+     * Has the host mounted the call surface (`@everfur/sdk/web/televet/call`)? Defaults to FALSE.
+     *
+     * Fail closed. A partner that has not said so gets a confirmation that promises only what it can keep.
+     */
+    readonly canJoinInApp?: boolean;
+    /**
+     * Replace what is shown when the in-page booking surface is not served for this tenant.
+     *
+     * The default is the paused card inside the booking chrome, whose Close is the way out: nothing leaves the
+     * page. A partner that wants the hosted visit offered here opts in explicitly:
+     * `renderUnavailable={() => <VetVisitButton prefer="redirect" />}`.
+     */
+    readonly renderUnavailable?: () => ReactNode;
+    /** The screen the flow starts on; `home` (the visits when one is ahead, otherwise booking) when omitted. */
+    readonly initialScreen?: TelevetScreen;
+    /**
+     * The heading level this flow's title claims. Defaults to 2.
+     *
+     * A DROP-IN WIDGET DOES NOT OWN YOUR PAGE'S `<h1>`. Pass 1 only when the flow IS the page in your app; every
+     * heading inside the flow then follows one level below. See `src/web/headingLevel.ts`.
+     */
+    readonly headingLevel?: number;
+    readonly style?: CSSProperties;
+    /** Your own placeholder while the entitlement verdict is pending on a cold mount. */
+    readonly renderPending?: () => ReactNode;
+    /** A class the host may hang its own layout rules on; the SDK sets no classes of its own. */
+    readonly className?: string;
+}
+declare function EverfurTelevetFlow(props: EverfurTelevetProps): ReactNode;
+/** The public prebuilt televet surface: the flow, landing on the visits or the booking. */
+declare const EverfurTelevet: typeof EverfurTelevetFlow;
+
+interface EverfurTelevetDialogProps {
+    /** What was opened: the pet and state for a booking, or the visit a reminder named. */
+    readonly request: EverfurTelevetFlowRequest;
+    /** Close the dialog. Called by the flow's own exits and by an Escape no screen handled. */
+    readonly onClose: () => void;
+}
+/** The in-page vet visit in a modal dialog. */
+declare function EverfurTelevetDialog({ request, onClose }: EverfurTelevetDialogProps): ReactNode;
+
+interface TelevetJoinScreenProps {
+    /** The consult to join. */
+    readonly consultId: string;
+    /** Host/test seam: inject a booking controller instead of building one from the provider's session. */
+    readonly controller?: TelevetBookingController | undefined;
+    /** Shown in the lobby while the clinician has not joined. Never invented. */
+    readonly clinicianName?: string | null | undefined;
+    /** The pet's name for the lobby's prep line. */
+    readonly petName?: string | null | undefined;
+    /** The way out: the member left the call, declined the notice, or pressed Leave on a refusal. */
+    readonly onLeave: () => void;
+    readonly style?: CSSProperties | undefined;
+}
+/** Mint the room credential for one consult and join it in the page. */
+declare function TelevetJoinScreen({ consultId, controller: injected, clinicianName, petName, onLeave, style }: TelevetJoinScreenProps): ReactNode;
+
+interface TelevetVisitsScreenProps {
+    /** Host/test seam: inject a booking controller instead of building one from the provider's session. */
+    readonly controller?: TelevetBookingController | undefined;
+    /** Join a visit: the flow mints the credential and opens the call behind the recording notice. */
+    readonly onJoin: (consult: TelevetConsult, petName: string | null) => void;
+    /** Move a visit. Absent, the control is omitted rather than rendered inert. */
+    readonly onReschedule?: ((consult: TelevetConsult) => void) | undefined;
+    /** Start a new booking. Absent, the book card is omitted. */
+    readonly onBook?: (() => void) | undefined;
+    /** Leave the visits: back to the screen under them, or out of the flow from its first screen. */
+    readonly onBack: () => void;
+    /** True when the visits are the flow's first screen, so the way out is the close control rather than Back. */
+    readonly isRoot?: boolean | undefined;
+    /** Bumped by the flow after a booking, a move or a call, so the list is read again. */
+    readonly revision?: number | undefined;
+    /** Injected by tests, so the split and the window can sit on either side of a boundary. */
+    readonly nowMs?: number | undefined;
+    readonly style?: CSSProperties | undefined;
+}
+declare function TelevetVisitsScreen({ controller: injected, onJoin, onReschedule, onBook, onBack, isRoot, revision, nowMs, style, }: TelevetVisitsScreenProps): ReactNode;
+
+type Css = CSSProperties;
+declare function makeVisitStyles(theme: EverfurTheme): {
+    screen: Css;
+    topBar: Css;
+    topBarStart: Css;
+    iconButton: Css;
+    textButton: Css;
+    panel: Css;
+    panelBody: Css;
+    panelHeader: Css;
+    panelTitle: Css;
+    count: Css;
+    bookTitle: Css;
+    list: Css;
+    row: Css;
+    rowHead: Css;
+    when: Css;
+    pet: Css;
+    chip: Css;
+    chipPositive: Css;
+    actions: Css;
+    note: Css;
+    notice: Css;
+    noticeTitle: Css;
+    noticeDanger: Css;
+    form: Css;
+    label: Css;
+    textarea: Css;
+    fieldError: Css;
+    empty: Css;
+    skeletons: Css;
+};
+type VisitStyles = ReturnType<typeof makeVisitStyles>;
+
+type TelevetCancelTerms = {
+    readonly status: 'loading';
+} | {
+    readonly status: 'ready';
+    readonly summary: string;
+} | {
+    readonly status: 'error';
+};
+interface TelevetCancelVisitFormProps {
+    readonly terms: TelevetCancelTerms;
+    readonly submitting: boolean;
+    /** The line to show when the last attempt did not land, or null. */
+    readonly failure: string | null;
+    readonly onConfirm: (reason: string) => void;
+    readonly onDismiss: () => void;
+    readonly onRetryTerms: () => void;
+    readonly styles: VisitStyles;
+}
+declare function TelevetCancelVisitForm({ terms, submitting, failure, onConfirm, onDismiss, onRetryTerms, styles, }: TelevetCancelVisitFormProps): ReactNode;
+
+/**
+ * The emergency interstitial's cards: ownerCopy.ts:1074-1077, rendered by `EmergencyInterstitial`
+ * (BookingFunnel.tsx:713-774). The number is the web app's own dialled constant (BookingFunnel.tsx:643), the
+ * same one its emergency notice gives in words, never parsed back out of the displayed line.
+ */
+declare const TELEVET_EMERGENCY_EXITS_WEB: Readonly<{
+    findEmergencyVet: "Find an emergency vet near you";
+    poisonControl: "ASPCA Animal Poison Control";
+    poisonControlDetail: "(888) 426-4435 · a fee may apply";
+    poisonControlTel: "tel:+18884264435";
+}>;
+declare const TELEVET_BOOKING_COPY_WEB: Readonly<{
+    /** :1037. The same words as the shared deck, restated so the web deck is complete for this screen. */
+    petSelectTitle: "Who is this visit for?";
+    /** :1054. The shared deck's "or Type to the vet what you're seeing" kept an "or" from a removed option. */
+    describeHeading: "Type to the vet what you're seeing";
+    /** :1056 `describeHint`, the web frame's line under that heading. */
+    describeHelpLong: "Describe the issues your pet is experiencing";
+    /** see-a-vet/copy.ts:264 `intakeStepTwoCopy.detail.placeholder`, which the web funnel's textarea uses. */
+    reasonPlaceholder: "She's been scratching her left ear a lot this week...";
+    /** :1094 `vetHeading`. The shared deck's "Your Vet" is the mobile card's title. */
+    yourVetTitle: "Which vet would you like to see?";
+    /** :1113 `timeHeading`. */
+    timeHeading: "Pick a date and time";
+    /** :1116 `reviewHeading`, drawn on the web frame where the mobile review draws none. */
+    reviewHeading: "Does this look right?";
+    /**
+     * :1047 `issuesHeading`, :1049 `issuesHint`, :1051 `otherIssue`. `{pet}` is DATA. The apostrophe is the
+     * web deck's typographic one, character for character.
+     */
+    issuesHeadingTemplate: "Select {pet}’s main issues";
+    issuesHint: "Can select more than 1";
+    otherIssue: "Other";
+    /** :1129 `bookedHeading`. `{vet}` is the booked clinician's served name; without one the shared title stays. */
+    bookedHeadingTemplate: "You're booked with {vet}";
+    /** :1141, capital C as the web frame draws it. */
+    addToCalendarCta: "Add to Calendar";
+    /** see-a-vet/copy.ts `statePolicyNoticeCopy.back`, the funnel's Back (FunnelFrame, BookingFunnel.tsx:280). */
+    backLabel: "Back";
+    /**
+     * The emergency interstitial (`Desktop - 18`): ownerCopy.ts:1069, :1071-1072, :1085 and :1091.
+     *
+     * "PLEASE CALL ONE OF THESE FIRST." ONLY OVER CARDS THAT ARE THERE. The consumer web draws its cards on every
+     * warning, so its lede can point at them. The SDK draws a card only when the host gave it one (a locator, the
+     * pet's clinic) or the owner approves poison control, so a warning with none reads `ledeWithoutExits`: the
+     * consumer MOBILE deck's lede for exactly that state (everfur-mobile copy.ts:726-730, "it must not tell an
+     * owner to call a list that is absent from the screen"), which is the shared deck's value.
+     */
+    emergency: Readonly<{
+        bannerTitle: "This can't wait for a scheduled call.";
+        lede: "What you're describing is the kind of thing vets want to see in person, now. Please call one of these first.";
+        ledeWithoutExits: string;
+        keepBookingCta: "I've handled this, continue with booking";
+        exitPrimaryVetTitle: "Call {petName}'s primary vet";
+        exitFindErTitle: string;
+        startCallHint: string;
+    }>;
+    stateBlockedTitle: string;
+    noCliniciansTitle: string;
+    noCliniciansBody: string;
+    noCliniciansRetryCta: string;
+    noCliniciansRegionBody: string;
+    reviewsLabel: string;
+    rescheduleFromTemplate: string;
+    rescheduleFailed: string;
+    keepExistingCta: string;
+    bookingPausedTitle: string;
+    slotsErrorTitle: string;
+    noSlotsTitle: string;
+    nextOpeningTemplate: string;
+    seeOtherVetsCta: string;
+    retryCta: string;
+    holdExpired: string;
+    slotTaken: string;
+    reasonTooLong: string;
+    shareRecordsOff: string;
+    confirmNotEntitled: string;
+    confirmFailed: string;
+    checkAvailabilityCta: string;
+    stateInterest: Readonly<{
+        cta: string;
+        submitting: string;
+        joinedTitle: string;
+        joinedBody: string;
+        failed: string;
+    }>;
+    media: Readonly<{
+        droppedTemplate: string;
+        droppedPluralTemplate: string;
+        refusedSizeTemplate: string;
+        refusedSizePluralTemplate: string;
+        refusedTypeTemplate: string;
+        refusedTypePluralTemplate: string;
+        refusedUnreadableTemplate: string;
+        refusedUnreadablePluralTemplate: string;
+    }>;
+    navTitle: string;
+    rescheduleNavTitle: string;
+    close: string;
+    continueCta: string;
+    addPetCta: string;
+    locationUnknownTitle: string;
+    locationUnknownBody: string;
+    locationUnknownCta: string;
+    locationBlockedTitle: string;
+    locationBlockedBody: string;
+    locationBlockedCta: string;
+    locationUnavailableTitle: string;
+    locationUnavailableBody: string;
+    stateAttestTemplate: string;
+    addPhotoCta: string;
+    removePhotoLabel: string;
+    summaryPet: string;
+    summaryVet: string;
+    summaryWhen: string;
+    summaryLength: string;
+    summaryReason: string;
+    summaryLengthTemplate: string;
+    confirmCta: string;
+    bookedTitle: string;
+    doneCta: string;
+    booked: Readonly<{
+        remindPromise: string;
+        summaryPromise: string;
+        joinPromise: string;
+        backToPet: string;
+        calendarAdded: string;
+        calendarFailedBody: string;
+    }>;
+    chrome: Readonly<{
+        closeHint: string;
+        discardTitle: string;
+        discardBody: string;
+        discardConfirmCta: string;
+        discardKeepCta: string;
+        noPetsTitle: string;
+        loadFailedTitle: string;
+        retryCta: string;
+    }>;
+    visit: Readonly<{
+        title: string;
+    }>;
+    loading: Readonly<{
+        pets: "Loading pets. Nothing to read yet.";
+        clinicians: "Loading vets. Nothing to read yet.";
+        slots: "Loading times. Nothing to read yet.";
+        consult: "Loading your visit. Nothing to read yet.";
+        progressTemplate: "Step {step} of {total}";
+    }>;
+}>;
+
+interface EverfurTelevetRescheduleProps {
+    /** The consult being moved. Null while the host is still loading it. */
+    readonly consult: TelevetConsult | null;
+    readonly onRescheduled?: (moved: TelevetConsult) => void;
+    /** Backing out. Never destructive: the original consult is left exactly as it was. */
+    readonly onCancel?: () => void;
+    /** Host/test seam: inject a booking controller instead of building one from the provider's session. */
+    readonly controller?: TelevetBookingController;
+    readonly style?: CSSProperties;
+    readonly testID?: string;
+}
+declare function EverfurTelevetReschedule(props: EverfurTelevetRescheduleProps): ReactNode;
+
+interface TelevetDay {
+    readonly key: string;
+    readonly iso: string;
+    readonly weekday: string;
+    readonly dayNumber: string;
+}
+interface TelevetDayStripProps {
+    readonly slots: readonly TelevetSlot[];
+    readonly selectedDayKey: string | null;
+    readonly onSelectDay: (day: TelevetDay) => void;
+    /**
+     * The group's accessible name.
+     *
+     * A PROP WITH NO DEFAULT STRING IN THIS FILE. Naming the group is required for the radiogroup to be
+     * announced usefully, and the name is user-facing copy, which this SDK does not author. The slot picker
+     * passes the ported deck's own heading down.
+     */
+    readonly groupLabel: string;
+}
+/** The day strip. Renders nothing when the window holds no readable day. */
+declare function TelevetDayStrip({ slots, selectedDayKey, onSelectDay, groupLabel }: TelevetDayStripProps): ReactNode;
+/**
+ * The distinct local days the slots cover, in server order.
+ *
+ * Exported for the picker, which needs the first day to seed the selection, and for the suite. Identical to
+ * the RN implementation: this is pure data and the port changes nothing about it.
+ */
+declare function televetDaysFromSlots(slots: readonly TelevetSlot[]): readonly TelevetDay[];
+
+interface TelevetSlotPickerProps {
+    /** The server's full window. Never truncated: the day filter is what bounds it. */
+    readonly slots: readonly TelevetSlot[];
+    /** The slot whose hold is in flight, or null. Disables the whole grid. */
+    readonly busySlotId: string | null;
+    readonly onPick: (slot: TelevetSlot) => void;
+    /** Rendered above the strip, for example a failure line from the container. */
+    readonly header?: ReactNode;
+    /**
+     * The accessible name for the day strip and the time grid.
+     *
+     * Required, with no default written here: it is user-facing copy and this SDK authors none. The containers
+     * pass the ported deck's own headings down.
+     */
+    readonly dayGroupLabel: string;
+    readonly timeGroupLabel: string;
+    readonly rowTestIdPrefix?: string;
+    readonly testID?: string;
+}
+declare function TelevetSlotPicker({ slots, busySlotId, onPick, header, dayGroupLabel, timeGroupLabel, rowTestIdPrefix, testID, }: TelevetSlotPickerProps): ReactNode;
+
+/** One "label ... value" row in the summary card, as a bound `<dt>` / `<dd>` pair. */
+declare function TelevetSummaryRow({ label, value, last, testID, }: {
+    readonly label: string;
+    readonly value: string;
+    /** The last row draws no divider, so the card does not end on a line. */
+    readonly last?: boolean;
+    readonly testID?: string;
+}): ReactNode;
+/**
+ * A consent tick.
+ *
+ * A REAL CHECKBOX. `accessibilityRole="checkbox"` with a `checked` state is what makes a screen reader announce
+ * it as an agreement rather than a button; in the DOM the element itself does that, and also brings focus,
+ * Space-to-toggle and the label-wraps-input behaviour for free.
+ */
+declare function TelevetConsentCheckbox({ label, checked, onToggle, testID, }: {
+    readonly label: string;
+    readonly checked: boolean;
+    readonly onToggle: (next: boolean) => void;
+    readonly testID?: string;
+}): ReactNode;
+/** The summary card's own frame, exported so the container does not re-declare it. */
+declare function TelevetSummaryCard({ children, testID }: {
+    readonly children: ReactNode;
+    readonly testID?: string;
+}): ReactNode;
+
+export { BACK_LABEL, type EverfurHeadingLevel, EverfurTelevet, EverfurTelevetBooking, type EverfurTelevetBookingProps, EverfurTelevetDialog, type EverfurTelevetDialogProps, EverfurTelevetFlow, EverfurTelevetFlowRequest, type EverfurTelevetProps, EverfurTelevetReschedule, type EverfurTelevetRescheduleProps, PetRef, TELEVET_BOOKING_COPY_WEB, TELEVET_EMERGENCY_EXITS_WEB, TelevetBookedScreen, type TelevetBookedScreenProps, TelevetBookingChrome, type TelevetBookingChromeProps, TelevetBookingController, TelevetBookingStep, type TelevetCalendarEvent, type TelevetCalendarWriter, type TelevetCancelTerms, TelevetCancelVisitForm, type TelevetCancelVisitFormProps, TelevetClinicianEmptyState, type TelevetClinicianEmptyStateProps, TelevetConsentCheckbox, TelevetConsult, type TelevetDay, TelevetDayStrip, type TelevetDayStripProps, type TelevetDiscardConfirm, TelevetEarlyEmergency, type TelevetEarlyEmergencyProps, TelevetEmergencyExits, type TelevetEmergencyExitsProps, TelevetEmptyRosterCause, TelevetEntitlementInterestState, type TelevetEntitlementInterestStateProps, type TelevetHistoryMode, TelevetIntakeMedia, type TelevetIntakeMediaItem, type TelevetIntakeMediaProps, TelevetJoinScreen, type TelevetJoinScreenProps, type TelevetLocationStatus, TelevetMediaDropNotice, type TelevetMediaDropNoticeProps, type TelevetMediaPicker, TelevetMediaShortfall, type TelevetPrimaryVet, type TelevetScreen, TelevetSlot, TelevetSlotPicker, type TelevetSlotPickerProps, TelevetStateInterestAction, type TelevetStateInterestActionProps, TelevetStateInterestAction$1 as TelevetStateInterestLifecycle, TelevetStateInterestWrite, TelevetSummaryCard, TelevetSummaryRow, TelevetTriageRead, TelevetVisitsScreen, type TelevetVisitsScreenProps, VetVisitIntent, televetConsultCalendarKey, televetDaysFromSlots, televetScreenForRequest };