@everfur/sdk 0.13.0 → 0.14.0

package/dist/threadOptions.d-9r4Csa7k.d.cts

@@ -0,0 +1,458 @@
+import { ReactNode, CSSProperties } from 'react';
+import { a as CapabilityDecision } from './resolve.d-CoQWUy1Y.cjs';
+import { E as EverfurError } from './EverfurError.d-8NHtlgzA.cjs';
+import { P as PetRef } from './ids.d-B2GAAifq.cjs';
+import { b as HealthPlanFocusDesign, c as HealthPlanFocusCopy, d as HealthPlanFocusClassNames, e as HealthPlanFocusIcon, f as HealthPlanItem, g as HealthPlanSubscription, h as HealthPlanOneBoxOrder, i as HealthPlanSubscriptionRepository, j as HealthPlanPageRepository, k as HealthPlanShopOrder, l as HealthPlanCheckoutProvider } from './focus.d-jQWp0hdK.cjs';
+import { H as HealthPlanBlanksFacts, a as HealthPlanPriceFormat, b as HealthPlanLayoutProps, c as HealthPlanEmptyCopy } from './usePresentation.d-DYTF_ZGf.cjs';
+import { L as LifecyclePort } from './LifecyclePort.d-Cr1p33a7.cjs';
+import { E as EverfurResult } from './EverfurResult.d-BFH-3s6E.cjs';
+import { i as EverfurPresentationInput } from './presentation.d-vy8kTGfR.cjs';
+
+/** Which overlay the focus layout has open, for a host that dims its own chrome under it. */
+type HealthPlanFocusOverlay = 'checkout' | 'manage' | 'started' | 'cart' | 'cartCheckout' | 'placed' | 'orders' | 'order' | 'weight' | null;
+/** Which layer `overlayContainer` is asked for: the checkout and manage sheets, the started screen, the toast. */
+type HealthPlanFocusLayer = 'sheet' | 'started' | 'toast';
+/** Handed to `onOverlayChange`, so a host's own back control can close what is open. */
+interface HealthPlanFocusOverlayControls {
+    /** Closes everything the layout has open. */
+    readonly close: () => void;
+    /** Closes the top screen or sheet only (a header's back). Absent before the shop: `close`. */
+    readonly back?: () => void;
+    /** The title for the host's header over a pushed screen ("Cart", "Order placed"); absent over a sheet. */
+    readonly title?: string;
+    /** True for a full screen (no bottom tabs under it): the cart, the order placed, the started screen. */
+    readonly full?: boolean;
+}
+/** The focus layout's options. Passing them to `EverfurHealthPlan` (`focus={...}`) opts the page in. */
+interface HealthPlanFocusOptions {
+    /**
+     * Your content for the layout. Omit it and `EverfurHealthPlan` reads the pet's plan page from Everfur (built from
+     * vet-approved templates and the pet's own facts) and draws that, with the page's checkout setting.
+     */
+    readonly design?: HealthPlanFocusDesign;
+    /** Your words over the SDK's buying words, on top of `design.copy`. Works with the backend page too. */
+    readonly copy?: Partial<HealthPlanFocusCopy>;
+    readonly classNames?: HealthPlanFocusClassNames;
+    /** Draw an icon your way (an `<svg><use href="#i-check"/></svg>` from your sprite). */
+    readonly renderIcon?: (icon: HealthPlanFocusIcon, className?: string) => ReactNode;
+    /** False never reads the subscription quote: the buy button is the one-time handoff only. Default true. */
+    readonly subscriptions?: boolean;
+    /**
+     * Where the checkout sheet, the started screen and the toast mount, asked per layer (a sheet over your whole
+     * frame, the started screen under your own header). Null or absent: `document.body`.
+     */
+    readonly overlayContainer?: (layer: HealthPlanFocusLayer) => HTMLElement | null;
+    /** A one-time buy handed to your checkout (no quote, or no one-box offer). Omit it and `onCheckout([item])` is called instead. */
+    readonly onBuy?: (item: HealthPlanItem) => void;
+    /** The "Why this product?" link. Omit it and the link is not drawn. */
+    readonly onMore?: (item: HealthPlanItem) => void;
+    /** One of `design.extras` was added (or taken back). Local state; the host runs its own cart. Omit it and the extras are not drawn. */
+    readonly onExtra?: (key: string, added: boolean) => void;
+    /** The checkup questions were added to (or taken off) the next visit. Local state; the host persists it. */
+    readonly onAddToVisit?: (added: boolean, questions: readonly string[]) => void;
+    readonly onOverlayChange?: (overlay: HealthPlanFocusOverlay, controls: HealthPlanFocusOverlayControls) => void;
+    /** A subscription changed (started, skipped, interval, cancelled), with the server's new state. */
+    readonly onSubscriptionChange?: (subscription: HealthPlanSubscription) => void;
+    /** A one-box order was recorded, with the server's order. */
+    readonly onOneBoxOrder?: (order: HealthPlanOneBoxOrder) => void;
+    /** Number and date locale. Defaults to the platform's. */
+    readonly locale?: string;
+    /** A repository of your own (a stub backend, tests). */
+    readonly subscriptionRepository?: HealthPlanSubscriptionRepository;
+    /**
+     * How the member leaves for Everfur's Stripe Checkout (`checkout: everfur_stripe` only). Defaults to
+     * `window.location.assign(url)`; a page inside a frame passes its own (the top window's).
+     */
+    readonly navigate?: (url: string) => void;
+    /** The plan page and checkout repository of your own (a stub backend, tests). */
+    readonly pageRepository?: HealthPlanPageRepository;
+    /**
+     * True turns Buy into Add to cart and draws the cart, its checkout, the orders and an order. Default: on when the
+     * checkout is Everfur's (`everfur_stripe`), off for a partner's own checkout. `shop: false` turns it off with
+     * Everfur's checkout too: Buy and Subscribe then go straight to Stripe Checkout.
+     */
+    readonly shop?: boolean;
+    /**
+     * True when Everfur texts the member the tracking number once it ships: the "tracking comes by text" lines are drawn.
+     * `EverfurHealthPlan` sets it from the plan page (`tracking_texts_enabled`). Default false: never promised.
+     */
+    readonly trackingTexts?: boolean;
+    /**
+     * The pet's sex, for "her" / "his" in the buying words; absent or null uses the pet's name ("Georgia's"), else
+     * "your pet". `EverfurHealthPlan` sets it from the plan page; a host design passes its own.
+     */
+    readonly petSex?: 'female' | 'male' | null;
+    /** The unit the weight sheet takes: `lb` (the default) or `kg`. */
+    readonly weightUnit?: 'lb' | 'kg';
+    /** The partner's own orders for this pet (its kits, its tests), listed after Everfur's. The partner's data, drawn as given. */
+    readonly shopOrders?: readonly HealthPlanShopOrder[];
+    /** "Get help with this order". Omit it and the link is not drawn. */
+    readonly onOrderHelp?: (orderKey: string) => void;
+    /**
+     * False: the pet's weight is unknown, so the dose is replaced by a row that asks for it. `EverfurHealthPlan` sets it
+     * from the plan page; a host design passes its own. Absent: the dose is drawn.
+     */
+    readonly weightKnown?: boolean;
+    /** Save the weight your way (a demo pet). Omit it and the pet's profile is updated (`updatePet`, `weightKg`). */
+    readonly onSaveWeight?: (weightKg: number, pounds: number) => Promise<EverfurResult<unknown>>;
+    /** The weight was saved; `EverfurHealthPlan` re-reads the plan page with it. */
+    readonly onWeightSaved?: (weightKg: number) => void;
+    /**
+     * True with `onConnectRecords`: the row that asks for the pet's vet records is drawn under the checkup.
+     * `EverfurHealthPlan` derives it from the pet's records read when you pass `onConnectRecords` and leave this out.
+     */
+    readonly recordsMissing?: boolean;
+    readonly onConnectRecords?: () => void;
+    /**
+     * Her three blanks: where her clinic request stands and what her records hold (`healthPlanBlanksFacts`). Null: no
+     * card. `EverfurHealthPlan` reads it from the pet's records when you pass `onConnectRecords` and leave this out.
+     */
+    readonly recordsBlanks?: HealthPlanBlanksFacts | null;
+    /**
+     * True when the member has no vet for this pet yet (the intro's "doesn't have a vet yet"). Absent: what
+     * `setHealthPlanNoVet` last said for this pet on this page, else false.
+     */
+    readonly noVet?: boolean;
+    /** The waiting card's button (`design.wait.action`). */
+    readonly onWaitAction?: () => void;
+}
+interface HealthPlanFocusProps extends Omit<HealthPlanFocusOptions, 'design'> {
+    readonly design: HealthPlanFocusDesign;
+    /** Whose checkout Buy and Subscribe run. `partner` (the default) is the handoff; `everfur_stripe` redirects to Stripe. */
+    readonly checkout?: HealthPlanCheckoutProvider;
+    readonly item: HealthPlanItem;
+    /** The pet's other plan items, drawn under the pick in plan order, each with its own buy. `EverfurHealthPlan` passes the plan's items minus the pick. */
+    readonly others?: readonly HealthPlanItem[];
+    /** True to draw each other item's category (the backend `category`) above its name, as `showCategory` does on the list cards. Default false. */
+    readonly showCategory?: boolean;
+    /**
+     * The plan's re-read signals, so the subscription state (the subscribed line, Manage, Subscribe) is read again with
+     * it: a foreground past the stale window, quietly. `EverfurHealthPlan` passes its own. Absent, the quote is read
+     * once.
+     */
+    readonly lifecycle?: LifecyclePort | null;
+    /** Change it to re-read the subscription state now, quietly. `EverfurHealthPlan` passes its `refreshKey`. */
+    readonly refreshKey?: string | number;
+    readonly petRef: PetRef;
+    readonly petName: string | null;
+    readonly onCheckout?: (items: readonly HealthPlanItem[]) => void;
+    readonly priceFormat?: HealthPlanPriceFormat;
+    readonly style?: CSSProperties;
+    readonly className?: string;
+}
+/** The focus layout over one plan item. `EverfurHealthPlan` mounts it; a partner can mount it over the hook too. */
+declare function HealthPlanFocus(props: HealthPlanFocusProps): ReactNode;
+
+interface EverfurHealthPlanProps extends HealthPlanLayoutProps {
+    /** The pet whose plan to show. Omit it and the provider's active pet is used. */
+    readonly petRef?: PetRef | null;
+    /** Called with the cart's items when the member presses checkout. Omit it and no checkout control is drawn. */
+    readonly onCheckout?: (items: readonly HealthPlanItem[]) => void;
+    /** Your own wording for a refused read. The retry control stays the SDK's. */
+    readonly renderNotice?: (error: EverfurError) => ReactNode;
+    /** What to show when the `healthPlan` capability is off. Defaults to the gate's own off state. */
+    readonly renderDisabled?: (decision: CapabilityDecision) => ReactNode;
+    readonly style?: CSSProperties;
+    readonly className?: string;
+    /**
+     * The focus layout's content: one issue, the free tips first, one product sized for the pet (subscribe or one
+     * box), the pet's other plan items after it (each with its own one-box buy), the signs to watch with the checkup
+     * questions, and your other offers. The words come from `focus.design`.
+     * It is drawn while the layout setting `healthPlanLayout` resolves to `focus_plan` (your `presentation` prop, else
+     * your console's render_hints.branding.presentation `health_plan_layout`), with or without these options (none:
+     * Everfur's plan page with the SDK's defaults); otherwise the page keeps the product grid. Signed out, loading,
+     * refused and empty states draw exactly as without it.
+     *
+     * Without `focus.design` the content is Everfur's plan page for the pet (`GET .../plan/page`), read again on a pet
+     * change: loading while it reads, the empty state when the page is null, the retry notice when it is refused. The
+     * page also says whose checkout runs Buy and Subscribe (`everfur_stripe` redirects to Stripe Checkout; `partner`
+     * keeps the `onBuy` / `onCheckout` handoff).
+     */
+    readonly focus?: HealthPlanFocusOptions;
+    /**
+     * The layout setting, `healthPlanLayout` (`standard` or `focus_plan`). Your value wins over the console's unless the
+     * console locks it. Absent everywhere, `standard`.
+     */
+    readonly presentation?: Pick<EverfurPresentationInput, 'healthPlanLayout'>;
+    /**
+     * When the plan is read again on its own: coming back to the page after more than a minute re-reads it quietly
+     * (the plan stays on screen), so a change made in another tab shows: the plan, the page and, in the focus layout,
+     * the subscription state (a subscription started elsewhere). Absent, Everfur uses the browser's own
+     * signal (the page becoming visible again; see `createBrowserLifecycle`). Pass your own port, or `null` to turn
+     * the re-read off.
+     */
+    readonly lifecycle?: LifecyclePort | null;
+    /** Change it to re-read the plan (and, in the focus layout, the subscription state) now, quietly (for example after your checkout completed). */
+    readonly refreshKey?: string | number;
+    /**
+     * Whether this pet has a plan to show: true once the plan (or its page) draws, false when the pet has none and the
+     * empty state has no words to draw (Q1: the page then draws nothing; hide your Health Plan tab for that pet).
+     * Not called while loading or after a refused read.
+     */
+    readonly onAvailability?: (available: boolean, petRef: PetRef | null) => void;
+    /** The empty state's Ask button (drawn only when `emptyAsk` has words). */
+    readonly onAsk?: () => void;
+    /** Your words for the empty state, over the SDK's (empty until Raph writes them: then nothing is drawn). */
+    readonly emptyCopy?: Partial<HealthPlanEmptyCopy>;
+}
+/** One pet's Health Plan on a web page. Mount it under the `EverfurProvider` from "@everfur/sdk/web". */
+declare function EverfurHealthPlan(props: EverfurHealthPlanProps): ReactNode;
+
+/** What `renderEmptyHeader` receives: ask a question in this thread, with no screen in between. */
+interface EverfurChatEmptyHeaderContext {
+    /** Send `prompt` as the member's next message in the open thread (the same path as a starter chip). */
+    ask(prompt: string): void;
+}
+/**
+ * The history bar: a "Chats" control with the member's thread count that opens the history drawer, and a "New
+ * chat" control. For a surface that passes `header={false}` and still wants the member's past chats.
+ */
+interface EverfurChatHistoryBar {
+    /** The history control's words ("Chats"). */
+    readonly chats: string;
+    /** The new-chat control's words ("New chat"). */
+    readonly newChat: string;
+    /** Classes per element; a class drops that element's inline default. */
+    readonly classNames?: {
+        readonly bar?: string;
+        readonly chats?: string;
+        readonly count?: string;
+        readonly newChat?: string;
+        /** The dot on "Chats" while some thread carries an unread reply. */
+        readonly unreadDot?: string;
+    };
+    /** Draw the two icons your way. */
+    readonly renderIcon?: (icon: 'history' | 'edit') => ReactNode;
+    /** Your own control after "Chats" (a pill that reopens a card you closed). Absent, nothing is drawn. */
+    readonly extra?: ReactNode;
+}
+/**
+ * The empty thread's own title and layout, for a host that draws it its way. The words are yours; a class drops
+ * that element's inline layout default (a starter chip keeps its tint). Absent, the empty state is Everfur's own.
+ */
+interface EverfurChatEmptyState {
+    /** The title over the starter chips, in place of "What can we help {pet} with today?". */
+    readonly title?: string;
+    readonly classNames?: {
+        /** The block that holds the title and the chips (under `renderEmptyHeader`'s card). */
+        readonly start?: string;
+        readonly title?: string;
+        readonly list?: string;
+        readonly chip?: string;
+    };
+    /**
+     * Fills for the chips that bring none of their own (Everfur's built-in chips, the backend's suggestions, a starter
+     * prompt without a `tint`), taken in turn: the first chip the first fill, and round again. Each is a fill (any CSS
+     * colour) and its ink. Absent or empty, those chips keep the theme's paint.
+     */
+    readonly chipTints?: readonly {
+        readonly tint: string;
+        readonly ink?: string;
+    }[];
+}
+/**
+ * The card a thread opened from a notification starts with, in place of the member's first bubble: drawn while
+ * the first message of the open thread is the surface's `initialAsk`.
+ */
+interface EverfurChatOpeningCard {
+    /** The line over the title ("Notification · 9:41 AM"). */
+    readonly kicker: string;
+    readonly title: string;
+    readonly body?: string;
+    /** The brand mark in the card's corner. */
+    readonly icon?: ReactNode;
+    /** Classes per element; a class drops that element's inline default. */
+    readonly classNames?: {
+        readonly card?: string;
+        readonly icon?: string;
+        readonly body?: string;
+    };
+}
+/**
+ * One card under an answer in the cards answer style (presentation `chat_answer_style: "cards"`): a record (a tile, the
+ * title, a meta line, a status pill and a chevron), a stat (the title, a meta line and a value), or a link to one of your
+ * screens. The words and the data are yours; Everfur holds none of them.
+ */
+interface EverfurChatAnswerCard {
+    /** Stable key within the answer. */
+    readonly key: string;
+    readonly title: string;
+    /** The small line under the title. */
+    readonly meta?: string;
+    /** A status pill; `tone` picks `classNames.pillTone[tone]`. */
+    readonly pill?: {
+        readonly label: string;
+        readonly tone?: string;
+    };
+    /** A stat card's value (`14` with the unit `lb`): drawn in place of the pill and the chevron. */
+    readonly value?: {
+        readonly amount: string;
+        readonly unit?: string;
+    };
+    /** The tile at the start: an icon of yours, or an image (https, or a path on your own origin); `tone` picks `classNames.tileTone[tone]`. */
+    readonly tile?: {
+        readonly icon?: ReactNode;
+        readonly imageUrl?: string;
+        readonly tone?: string;
+    };
+    /** Picks `classNames.cardVariant[variant]` (for example a highlighted plan card). */
+    readonly variant?: string;
+    /** Given, the card is a button that calls this. Absent, a static card. */
+    readonly onPress?: () => void;
+    /**
+     * A card of your own (the host card slot): given, Everfur draws this node in the card's place, inside the card's
+     * class (`classNames.card` plus `cardVariant[variant]`), and ignores the tile, the pill, the value and `onPress`.
+     * Use it for a card Everfur's shapes do not cover (for example a breed-mix chart). If it throws, the slot draws
+     * nothing and the answer still draws. `title` stays its accessible name.
+     */
+    readonly render?: () => ReactNode;
+}
+/** What `answerCards.cards` receives: the settled answer's text and the question it answered. */
+interface EverfurChatAnswerContext {
+    readonly answer: string;
+    readonly question: string | null;
+    /** The answer's message id, stable for the life of the thread. */
+    readonly messageId: string;
+}
+/**
+ * The cards answer style's content and classes (used while presentation `chat_answer_style` is `cards`). Every part is
+ * optional; absent, the answer is drawn open (no bubble) with Everfur's own sources and footer. The words are yours.
+ */
+interface EverfurChatAnswerCards {
+    /** The line over each answer (an icon and your words, "Read her test results"). Absent, the assistant's name line. */
+    readonly byline?: {
+        readonly label: string;
+        readonly icon?: ReactNode;
+    };
+    /** Your cards under a settled answer (records, stats, a link to your plan). A throw draws none. */
+    readonly cards?: (context: EverfurChatAnswerContext) => readonly EverfurChatAnswerCard[];
+    /**
+     * Two feedback chips in place of the footer's thumbs, mapped to thumbs up and thumbs down; the footer's Copy control
+     * stays beside them (`classNames.copy`). Absent, Everfur's own footer.
+     */
+    readonly feedback?: {
+        readonly helpful: string;
+        readonly notHelpful: string;
+    };
+    /** Your own rows at the top of the follow-ups ("See her Health Plan"), for the answer it receives. */
+    readonly followUpActions?: (context: EverfurChatAnswerContext) => readonly EverfurChatFollowUpAction[];
+    /** Draw the chevron your way. Absent, Everfur's glyph. */
+    readonly renderIcon?: (icon: 'chevron') => ReactNode;
+    /** Classes per element; a class drops that element's inline default. */
+    readonly classNames?: {
+        /** The answer row (the by-line, the body, the cards, the feedback). */
+        readonly answer?: string;
+        readonly byline?: string;
+        readonly body?: string;
+        /** The owner's question bubble. */
+        readonly question?: string;
+        readonly cards?: string;
+        readonly card?: string;
+        readonly cardStat?: string;
+        readonly cardVariant?: Readonly<Record<string, string>>;
+        readonly tile?: string;
+        readonly tileTone?: Readonly<Record<string, string>>;
+        readonly title?: string;
+        readonly meta?: string;
+        readonly pill?: string;
+        readonly pillTone?: Readonly<Record<string, string>>;
+        readonly value?: string;
+        readonly feedback?: string;
+        /** The Copy control beside the feedback chips. */
+        readonly copy?: string;
+        /** The block of follow-ups under the answer, its label and each row. */
+        readonly followUps?: string;
+        readonly followUpsLabel?: string;
+        readonly followUp?: string;
+        readonly followUpAction?: string;
+        /** The safety disclaimer when presentation `safety_disclaimer_placement` is `answer_footer`. */
+        readonly disclaimer?: string;
+    };
+}
+/** A row of yours at the top of the follow-ups under an answer. */
+interface EverfurChatFollowUpAction {
+    readonly key: string;
+    readonly label: string;
+    readonly icon?: ReactNode;
+    readonly onPress: () => void;
+}
+/**
+ * The card at the top of the empty thread (presentation `chat_top_card: "focus"`): one finding, in your words, with
+ * an action of yours and a question it can ask in the thread. A close control folds it into a pill beside "Chats" in
+ * the history bar, which opens it again.
+ */
+interface EverfurChatTopCard {
+    /** The small heading ("Her focus"). */
+    readonly kicker: string;
+    /** A source badge ("<your brand> results"). */
+    readonly badge?: string;
+    readonly title: string;
+    /** The finding: a bold lead and the rest of the sentence. */
+    readonly lead?: string;
+    readonly body?: string;
+    /** Your action ("See her Health Plan"). */
+    readonly action?: {
+        readonly label: string;
+        readonly onPress: () => void;
+    };
+    /** A question the card asks in this thread ("What does it mean?" sends `prompt`). */
+    readonly ask?: {
+        readonly label: string;
+        readonly prompt: string;
+    };
+    /** The close control's accessible name; given, the card can close to the pill. */
+    readonly closeLabel?: string;
+    /** The pill's words while the card is closed (defaults to `kicker`). */
+    readonly pill?: string;
+    /** Draw the close glyph your way. */
+    readonly renderIcon?: (icon: 'close') => ReactNode;
+    /** Classes per element; a class drops that element's inline default. */
+    readonly classNames?: {
+        readonly wrap?: string;
+        readonly card?: string;
+        readonly kicker?: string;
+        readonly badges?: string;
+        readonly badge?: string;
+        readonly close?: string;
+        readonly title?: string;
+        readonly content?: string;
+        readonly finding?: string;
+        readonly dot?: string;
+        readonly actions?: string;
+        readonly action?: string;
+        readonly ask?: string;
+        readonly pill?: string;
+    };
+}
+/**
+ * The history bottom sheet (presentation `chat_history_style: "sheet"`): the member's chats by day, each with its
+ * preview, and a new chat button. Its words and classes; absent, Everfur's own words and inline look.
+ */
+interface EverfurChatHistorySheet {
+    /** The sheet's small title ("Chats with Ask <your brand>"). Absent, Everfur's history heading. */
+    readonly title?: string;
+    /** Where the sheet and its scrim mount (your app frame), so the scrim covers it. Absent, inside the chat. */
+    readonly container?: () => HTMLElement | null;
+    /** Draw the icons your way. */
+    readonly renderIcon?: (icon: 'close' | 'chat' | 'edit') => ReactNode;
+    readonly classNames?: {
+        readonly scrim?: string;
+        readonly sheet?: string;
+        /** Added to the scrim and the sheet while open (for a stylesheet that animates them in). */
+        readonly open?: string;
+        readonly grab?: string;
+        readonly top?: string;
+        readonly title?: string;
+        readonly close?: string;
+        readonly day?: string;
+        readonly row?: string;
+        readonly icon?: string;
+        readonly time?: string;
+        /** A row's time while it carries an unread reply (with `time`), and the dot under it. */
+        readonly timeUnread?: string;
+        readonly unreadDot?: string;
+        readonly newChat?: string;
+    };
+}
+
+export { type EverfurChatTopCard as E, HealthPlanFocus as H, EverfurHealthPlan as a, type EverfurHealthPlanProps as b, type HealthPlanFocusLayer as c, type HealthPlanFocusOptions as d, type HealthPlanFocusOverlay as e, type HealthPlanFocusOverlayControls as f, type HealthPlanFocusProps as g, type EverfurChatEmptyHeaderContext as h, type EverfurChatEmptyState as i, type EverfurChatHistoryBar as j, type EverfurChatOpeningCard as k, type EverfurChatAnswerCards as l, type EverfurChatHistorySheet as m, type EverfurChatAnswerCard as n, type EverfurChatAnswerContext as o, type EverfurChatFollowUpAction as p };