@everfur/sdk 0.3.0 → 0.5.0

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

@@ -0,0 +1,566 @@
+import { ReactNode, ComponentType, ReactElement } from 'react';
+import { StyleProp, ViewStyle } from 'react-native';
+import { P as PetRef } from '../../ids-B2GAAifq.js';
+export { B as Brand, _ as __brand } from '../../ids-B2GAAifq.js';
+import { T as TelevetEmptyRosterCause, a as TelevetStateInterestAction$1, b as TelevetMediaShortfall, c as TelevetConsult, d as TelevetBookingStep, e as TelevetBookingController, f as TelevetTriageRead, g as TelevetStateInterestWrite, h as TelevetCancelReceipt, 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 TelevetCancellationPolicy, I as TelevetClinician, J as TelevetEarlyTriage, K as TelevetEmptyRosterView, L as TelevetJoinReadiness, 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, an as televetJoinOpensAtMs, ao as televetJoinReadiness, 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';
+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 pet's own clinic, when the HOST holds it.
+ *
+ * NOT READ FROM THE WIRE, and this is the one prop on this surface that could be mistaken for a gap. The
+ * consumer reads `GET /pets/{pet_id}/primary-vet` (TelevetEarlyEmergency.tsx:54); the partner plane has no
+ * primary-vet concept at all, so there is nothing for the SDK to read. A partner that already holds its
+ * customer's clinic can pass it and get the consumer's exact row; absent, the row is simply not drawn, which
+ * is what the consumer does for a pet with no clinic on file, a read that failed, or one still in flight
+ * (TelevetEarlyEmergency.tsx:28-30).
+ *
+ * NO NUMBER IS EVER INVENTED FOR THIS SCREEN. `dial` is the host's own action, not a `tel:` this file
+ * assembles, so the SDK never parses a phone number back out of a displayed line.
+ */
+interface TelevetPrimaryVet {
+    /** The clinic or the vet's name. Shown under the title; absent, the title stands alone. */
+    readonly detail?: string | null;
+    /**
+     * Places the call. ABSENT MEANS THE CARD IS NOT PRESSABLE: the consumer names the clinic without a dial
+     * action rather than inventing one when the directory holds no number (TelevetEarlyEmergency.tsx:107-113).
+     */
+    readonly dial?: (() => void) | undefined;
+}
+/**
+ * THE EXIT ROWS, on both places the warning is drawn: in place of Describe and at Confirm. The consumer mobile
+ * screen's order (TelevetEarlyEmergency.tsx:73-75 and :91): find an emergency vet, then the pet's own clinic.
+ * Poison control is NOT here, which is the mobile app's own decision (its fee line is a claim about a third
+ * party's charge, served there as a versioned document); the web port shows it because the web app does.
+ */
+declare function TelevetEmergencyExits({ petName, primaryVet, onFindEmergencyVet, }: {
+    readonly petName?: string | null | undefined;
+    readonly primaryVet?: TelevetPrimaryVet | null | undefined;
+    readonly onFindEmergencyVet?: (() => void) | undefined;
+}): ReactNode;
+
+interface TelevetEarlyEmergencyProps {
+    /** The pet's name, for the primary-vet row. Null drops the row, as the consumer does. */
+    readonly petName?: string | null;
+    readonly primaryVet?: TelevetPrimaryVet | null;
+    /**
+     * The host's own emergency-vet locator. The consumer's row opens a map search (`FindAVetButton`); the SDK
+     * opens nothing outside the app, so the row renders only when the host can take the member somewhere itself.
+     */
+    readonly onFindEmergencyVet?: (() => void) | undefined;
+    /** "I have handled this, keep booking". The ONLY way past this screen. */
+    readonly onContinue: () => void;
+}
+/**
+ * THE EMERGENCY WARNING, IN PLACE OF DESCRIBE, when the classifier says the owner's words may be an
+ * emergency. This is the clinical-safety surface on this flow.
+ *
+ * THE SAME WORDS AND THE SAME ACTIONS AS THE WARNING AT CONFIRM (`COPY.emergency`), which is what makes the
+ * two positions one question rather than two: the review step's `televet-review-emergency` branch renders the
+ * same title, the same lede and the same acknowledgement label.
+ *
+ * ── IT CANNOT BE SKIPPED PAST, AND THAT IS A PROPERTY OF THE CONTAINER, NOT OF THIS FILE ────────────────
+ * Three things hold it, all in `BookingContainer`:
+ *   1. It REPLACES the intake step while `triage.open` is true, so there is no Continue behind it and no
+ *      scroll that reaches one. It is not an overlay over a live form.
+ *   2. The chrome's Back closes the WARNING and returns to the words, without recording an acknowledgement,
+ *      so leaving is going back to edit rather than going forward (mobile's own rule,
+ *      TelevetBookingContainer.tsx:1096-1102).
+ *   3. `emergency_acknowledged` is tied to the EXACT WORDS it was answered for, so editing the reason after
+ *      acknowledging asks the question again rather than carrying a standing override.
+ *
+ * WHAT IS NOT HERE: the board's ER row and the poison-control row. Neither may be drawn without a verified
+ * number, and the consumer withholds both for the same reason (`COPY.emergency`'s own note). The lede no
+ * longer tells the member to "call one of these first", because that sentence was authored into this SDK and
+ * pointed at rows that are not on screen; see the copy deck.
+ */
+declare function TelevetEarlyEmergency({ petName, primaryVet, onFindEmergencyVet, onContinue, }: TelevetEarlyEmergencyProps): ReactNode;
+interface TelevetStateInterestActionProps {
+    /** Null renders NOTHING. See this file's header: no seam, no control. */
+    readonly action: TelevetStateInterestAction$1 | null;
+    readonly testIDPrefix: string;
+}
+/**
+ * ASK TO BE TOLD WHEN THE FACT ON SCREEN CHANGES. Presentation only: the caller decides whether this state
+ * is a licensure gap, and this control renders the write's lifecycle without ever treating a failure as a
+ * join (ported from TelevetStateInterestAction.tsx:15-55).
+ */
+declare function TelevetStateInterestAction({ action, testIDPrefix, }: TelevetStateInterestActionProps): ReactNode;
+interface TelevetClinicianEmptyStateProps {
+    /** Why the roster is empty. Picks which sentence is TRUE; see `clinicianEmptyState.ts`. */
+    readonly cause: TelevetEmptyRosterCause;
+    /** Re-reads the roster. Rendered only when the cause is one a retry could change. */
+    readonly onRetry?: (() => void) | undefined;
+    /** The interest write's lifecycle, or null. Null renders no control. */
+    readonly stateInterest?: TelevetStateInterestAction$1 | null;
+}
+/**
+ * THE TERMINAL STATE FOR A RESOLVED, STATE-SCOPED EMPTY CLINICIAN ROSTER.
+ *
+ * Network state belongs to the container; this component only presents the actions it is given, which is the
+ * consumer's own division (TelevetClinicianEmptyState.tsx:11-14).
+ *
+ * THE RETRY FOLLOWS THE CAUSE, NOT THE SCREEN. On a licensure gap there is no retry at all, because the
+ * answer will not change by evening; on a dark surface there is one, because the read may yet work. That
+ * decision is in `televetEmptyRosterView` so both platforms cannot disagree about it.
+ */
+declare function TelevetClinicianEmptyState({ cause, onRetry, stateInterest, }: TelevetClinicianEmptyStateProps): ReactNode;
+interface TelevetEntitlementInterestStateProps {
+    /**
+     * Opens the state-scoped roster read and NOTHING ELSE. Absent, the card stands alone.
+     *
+     * It never opens clinician selection, slots or the review: the consumer's docblock is explicit that this
+     * exists only because an empty licensed roster can lead to the state-interest action
+     * (TelevetEntitlementInterestState.tsx:9-15).
+     */
+    readonly onCheckAvailability?: (() => void) | undefined;
+}
+/**
+ * THE SUBSCRIPTION TRUTH WITH THE ONE DELIBERATELY NON-BOOKING ESCAPE HATCH.
+ *
+ * WHAT CHANGED FROM WHAT THIS SURFACE HAD. The container already rendered `confirmNotEntitled` in a bare
+ * card with no action, on the reasoning that "nothing the owner presses inside the booking flow grants an
+ * entitlement". That reasoning is correct and is not what this adds: the escape hatch does not grant
+ * anything, it reads the roster, and it exists because the member may be in a state where no clinician is
+ * licensed at all - which is a fact they are owed regardless of what they are entitled to, and the one route
+ * from this screen to the interest write.
+ */
+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.
+ *
+ * MOUNTED ON BOTH THE REVIEW STEP AND THE BOOKED CONFIRMATION, and that is the point rather than a
+ * duplication. The consumer moved it after finding it only on review, which unmounts the instant the booking
+ * succeeds: "on the common path the owner saw it for as long as the Confirm spinner ran and never again. The
+ * confirmation is where a 'your photo did not reach the vet' line actually has to be read"
+ * (MediaDropNotice.tsx:14-19).
+ *
+ * RENDERS NOTHING WHEN THERE IS NOTHING TO SAY, so it is mounted unconditionally and the caller needs no
+ * branch of its own.
+ */
+declare function TelevetMediaDropNotice({ shortfall, testIDPrefix, }: TelevetMediaDropNoticeProps): ReactNode;
+
+/** 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-tap 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 for a refused permission or no calendar at all. */
+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 app? Defaults to false.
+     *
+     * Fail closed: a host that has not said so is assumed not to have the native video modules, and the in-app
+     * join promise is withheld rather than printed on a hope.
+     */
+    readonly canJoinInApp?: boolean;
+}
+declare function TelevetBookedScreen({ consult, petName, onDone, onAddToCalendar, canJoinInApp, }: TelevetBookedScreenProps): ReactNode;
+
+/**
+ * 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 uses React Native's `Alert`, which is what the consumer does.
+ */
+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. 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;
+}
+declare function TelevetBookingChrome({ step, furthestIndex, title, canGoBack, isDirty, onBack, onClose, onConfirmDiscard, }: 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 consumer gets it from its shared back button, which owns the same string.
+ */
+declare const BACK_LABEL = "Back";
+
+/** 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 or the permission was refused. The SDK takes no picker
+ * dependency: on the consumer app this is expo-image-picker behind `pickMediaFromLibrary`, and a partner
+ * supplies whichever picker its app already has.
+ *
+ * `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;
+}
+declare function TelevetIntakeMedia({ media, onChange, onPickMedia }: 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 device 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 stack. */
+    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 uses React Native's `Alert`. */
+    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 exactly as it did before: straight from the
+     * description to the vet, with the server's own `emergency_ack_required` refusal still waiting at Confirm.
+     * That is not a degraded mode, it is the consumer app's own rule for a triage read that could not answer
+     * (`useEarlyTriage`): a failed pre-read costs the member the screen's early position, never the check.
+     *
+     * IT IS A SEAM BECAUSE `POST /widget/v1/televet/consults/triage` IS NOT SERVED. Verified on EFBackend main
+     * on 2026-09-22 against the route decorators under services/api/app/domains/partner_televet. A partner
+     * whose own stack can classify free text may wire it; nothing here invents a verdict.
+     */
+    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, which is the consumer's own behaviour for a null action and is
+     * deliberate rather than a gap. `POST /widget/v1/televet/state-interest` does not exist on the partner
+     * plane at all (verified with the route decorators above, and unlike the booking routes it is not in the
+     * agreed in-flight surface either), so a button here would post to a 404 and tell the member their one way
+     * out did not save, every time they pressed it.
+     */
+    readonly onStateInterest?: TelevetStateInterestWrite;
+    /**
+     * THE PET'S OWN CLINIC, for the emergency screen's one exit row.
+     *
+     * The consumer reads `GET /pets/{pet_id}/primary-vet`; the partner wire has no primary-vet concept, so a
+     * host that already holds its customer's clinic supplies it here and gets the consumer's exact row. Absent,
+     * the row is not drawn, which is what the consumer does for a pet with no clinic on file.
+     */
+    readonly primaryVet?: TelevetPrimaryVet | null;
+    /** The host's own emergency-vet locator. Absent, the emergency screens draw no find-a-vet row. */
+    readonly onFindEmergencyVet?: () => void;
+    /**
+     * Has the host PROVEN it can host the call in app? Defaults to false.
+     *
+     * Fail closed: without the native video modules the confirmation must not promise an in-app 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 app by default;
+     * a host that wants the hosted visit offered here passes `() => <VetVisitButton prefer="redirect" />`.
+     */
+    readonly renderUnavailable?: () => ReactNode;
+    readonly style?: StyleProp<ViewStyle>;
+    readonly testID?: string;
+}
+declare function EverfurTelevetBooking(props: EverfurTelevetBookingProps): 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. */
+ | {
+    readonly name: 'visits';
+}
+/** One visit before its call: the time, the vet, the join, the move and the cancel. */
+ | {
+    readonly name: 'consult';
+    readonly consult: TelevetConsult;
+} | {
+    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;
+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 device 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 navigator 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 app, 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;
+    /**
+     * Has the host installed the native video modules and wired the call surface? 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-app 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
+     * app. 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;
+    readonly style?: StyleProp<ViewStyle>;
+    /** Your own placeholder while the entitlement verdict is pending on a cold mount. */
+    readonly renderPending?: () => ReactNode;
+}
+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 EverfurTelevetModalProps {
+    /** What was opened: the pet and state for a booking, or the visit a reminder named. */
+    readonly request: EverfurTelevetFlowRequest;
+    /** Close the modal. Called by the flow's own exits and by a back press no screen handled. */
+    readonly onClose: () => void;
+}
+/** The in-app vet visit in a full-screen modal. */
+declare function EverfurTelevetModal({ request, onClose }: EverfurTelevetModalProps): 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, or pressed Leave on the notice or a refusal. */
+    readonly onLeave: () => void;
+    readonly style?: StyleProp<ViewStyle>;
+}
+/** Mint the room credential for one consult and join it in the app. */
+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;
+    /** Open one visit: its time, its vet, its join, its move and its cancel. */
+    readonly onOpenVisit: (consult: TelevetConsult) => void;
+    /** Start a new booking. Absent, the book card and the empty state's button are omitted, never inert. */
+    readonly onBook?: (() => void) | undefined;
+    /** The chevron: back to where the member came from, or out of the flow from its first screen. */
+    readonly onBack: () => void;
+    /** Bumped by the flow after a booking, a move, a cancel or a call, so the list is read again. */
+    readonly revision?: number | undefined;
+    /** Injected by tests, so the split can sit on either side of a window. */
+    readonly nowMs?: number | undefined;
+    readonly style?: StyleProp<ViewStyle>;
+}
+declare function TelevetVisitsScreen({ controller: injected, onOpenVisit, onBook, onBack, revision, nowMs, style, }: TelevetVisitsScreenProps): ReactNode;
+
+interface TelevetConsultScreenProps {
+    /** The visit, as the list that opened it read it. Re-read on mount; shown while the re-read is in flight. */
+    readonly consult: TelevetConsult;
+    /** Host/test seam: inject a booking controller instead of building one from the provider's session. */
+    readonly controller?: TelevetBookingController | undefined;
+    /** Join the visit: the flow mints the credential and opens the call behind the recording notice. */
+    readonly onJoin: (consult: TelevetConsult, petName: string | null) => void;
+    /** Move the visit. Absent, the control is omitted rather than rendered inert. */
+    readonly onReschedule?: ((consult: TelevetConsult) => void) | undefined;
+    /** Called after the server accepted a cancellation, so the flow can read the visits again. */
+    readonly onCancelled?: ((receipt: TelevetCancelReceipt) => void) | undefined;
+    readonly onBack: () => void;
+    /** Bumped by the flow after a move or a call, so the visit is read again. */
+    readonly revision?: number | undefined;
+    /** Injected by tests. Left undefined in the app so the screen uses a clock that moves. */
+    readonly nowMs?: number | undefined;
+    readonly style?: StyleProp<ViewStyle>;
+}
+declare function TelevetConsultScreen({ consult: opened, controller: injected, onJoin, onReschedule, onCancelled, onBack, revision, nowMs, style, }: TelevetConsultScreenProps): ReactNode;
+
+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?: StyleProp<ViewStyle>;
+    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 day strip. Renders nothing when the window holds no readable day. */
+declare function TelevetDayStrip({ slots, selectedDayKey, onSelectDay }: 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.
+ */
+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 ListHeaderComponent?: ComponentType | ReactElement | null;
+    readonly rowTestIdPrefix?: string;
+    readonly testID?: string;
+}
+declare function TelevetSlotPicker({ slots, busySlotId, onPick, ListHeaderComponent, rowTestIdPrefix, testID, }: TelevetSlotPickerProps): ReactNode;
+
+/** One "label ... value" row in the summary card. */
+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, not a pill button. A filled pill reads as "press to continue" while a checkbox reads as
+ * "you are agreeing to this", and these ticks are the owner's licensure attestation and their cancellation
+ * agreement. `accessibilityRole="checkbox"` with a `checked` state is also what makes a screen reader announce
+ * it as an agreement rather than a button.
+ */
+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, EverfurTelevet, EverfurTelevetBooking, type EverfurTelevetBookingProps, EverfurTelevetFlow, EverfurTelevetFlowRequest, EverfurTelevetModal, type EverfurTelevetModalProps, type EverfurTelevetProps, EverfurTelevetReschedule, type EverfurTelevetRescheduleProps, PetRef, TelevetBookedScreen, type TelevetBookedScreenProps, TelevetBookingChrome, type TelevetBookingChromeProps, TelevetBookingController, TelevetBookingStep, type TelevetCalendarEvent, type TelevetCalendarWriter, TelevetCancelReceipt, TelevetClinicianEmptyState, type TelevetClinicianEmptyStateProps, TelevetConsentCheckbox, TelevetConsult, TelevetConsultScreen, type TelevetConsultScreenProps, type TelevetDay, TelevetDayStrip, type TelevetDayStripProps, type TelevetDiscardConfirm, TelevetEarlyEmergency, type TelevetEarlyEmergencyProps, TelevetEmergencyExits, TelevetEmptyRosterCause, TelevetEntitlementInterestState, type TelevetEntitlementInterestStateProps, 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 };