@everfur/sdk 0.1.1 → 0.4.0

package/dist/branding-CsRdeNwK.d.ts

@@ -0,0 +1,566 @@
+/** The fixed set of slot names, in the order the surfaces list them. */
+declare const THEME_SLOT_NAMES: readonly ["composerInput", "sendButton", "userBubble", "assistantBubble", "recordCard", "vetVisitButton", "primaryButton", "link"];
+type EverfurThemeSlotName = (typeof THEME_SLOT_NAMES)[number];
+/** The allow-listed paint keys a slot accepts. */
+declare const THEME_SLOT_KEYS: readonly ["backgroundColor", "borderColor", "borderRadius", "textColor"];
+type EverfurThemeSlotKey = (typeof THEME_SLOT_KEYS)[number];
+/** One slot's paint: every key optional; a key that is absent keeps the surface's own token. */
+interface EverfurThemeSlot {
+    /** Normalized colour (`#RRGGBB` or `rgba(...)`). */
+    readonly backgroundColor?: string;
+    readonly borderColor?: string;
+    /** A corner radius in dp/px; never negative. */
+    readonly borderRadius?: number;
+    /**
+     * Normalized colour; guarded at 4.5:1 against `backgroundColor`, or against the slot's default ground when the
+     * slot sets no background (see `guardSlotContrast`).
+     */
+    readonly textColor?: string;
+}
+/** The slot map a resolved theme carries: only the slots that were set, each frozen. */
+type EverfurThemeSlots = Readonly<Partial<Record<EverfurThemeSlotName, EverfurThemeSlot>>>;
+/** The minimum text-on-background ratio a slot may paint (WCAG AA body text). */
+declare const SLOT_MIN_CONTRAST = 4.5;
+/**
+ * Parse an untrusted `slots` blob into the typed slot map. Unknown slot names and unknown keys are ignored, a
+ * malformed colour or radius is dropped, and a slot left with no valid key is dropped. Returns null when nothing
+ * valid remains (callers read null as "unset"). Never throws.
+ */
+declare function parseThemeSlots(json: unknown): EverfurThemeSlots | null;
+/**
+ * Overlay `over` onto `base` slot by slot: a slot the overlay names REPLACES the base slot whole (the backend's
+ * overlay unit, so `slots.<name>` locks and overlays agree); a slot it does not name is kept. Either side may be
+ * null. Returns a frozen map (the same reference when one side is null or empty).
+ */
+declare function mergeThemeSlots(base: EverfurThemeSlots | null, over: EverfurThemeSlots | null): EverfurThemeSlots;
+/** The minimum ratio a slot's edge may reach on its ground (WCAG 1.4.11, the boundary of a control). */
+declare const SLOT_MIN_BORDER_CONTRAST = 3;
+/**
+ * The ground each slot's text sits on when the slot sets no background of its own: the surface's default paint
+ * at that place, as the resolver knows it. Every slot lists at least one ground; a text colour must read on all
+ * of them (the link list names every ground a text link is drawn on).
+ */
+type SlotGrounds = Readonly<Record<EverfurThemeSlotName, readonly string[]>>;
+/**
+ * The contrast guard: every text colour a slot paints must reach `SLOT_MIN_CONTRAST` on the ground it is drawn on,
+ * and every edge `SLOT_MIN_BORDER_CONTRAST` on the fill it bounds.
+ *   - A TRANSLUCENT background whose seats straddle the white/black crossover is collapsed to the opaque colour
+ *     it shows over the slot's primary ground FIRST (`collapseUnsatisfiableFill`), because such a slot has no
+ *     readable ink while it means two colours at once. Everything below then measures against one seat.
+ *   - A slot that supplies a background: its ink is measured on that fill AS THE EYE SEES IT (`seatsOf`, the fill
+ *     composited onto the surface's default ground at that slot), and a missing or failing one is replaced by the
+ *     ink that fill is guaranteed to carry (`legibleOn`), then pushed until it reads on every seat.
+ *   - A slot without one: its `textColor` is measured on the slot's DEFAULT ground (`grounds`, the surface's own
+ *     paint there) and, when it fails, pushed toward the legible pole of that ground until it reads, so a text-only
+ *     slot can never paint invisible text either. Without `grounds` such a slot keeps its colour as supplied.
+ *   - An edge (`borderColor`) is measured on the fill it bounds (the same seats) and pushed the same way when it
+ *     reads below 3:1.
+ * Returns the same reference when nothing changes.
+ */
+declare function guardSlotContrast(slots: EverfurThemeSlots, grounds?: SlotGrounds): EverfurThemeSlots;
+
+/**
+ * One slot's paint on the `theme` prop; colours in any form `parseColor` reads, the radius in dp/px. The console's
+ * snake_case wire keys are accepted beside the camelCase ones.
+ */
+interface EverfurThemeSlotInput {
+    readonly backgroundColor?: string | number;
+    readonly background_color?: string | number;
+    readonly borderColor?: string | number;
+    readonly border_color?: string | number;
+    readonly borderRadius?: number | string;
+    readonly border_radius?: number | string;
+    readonly textColor?: string | number;
+    readonly text_color?: string | number;
+}
+/** The `slots` map on the `theme` prop: any subset of the eight slot names. */
+type EverfurThemeSlotsInput = Readonly<Partial<Record<EverfurThemeSlotName, EverfurThemeSlotInput>>>;
+/**
+ * The faces a theme names: the three text weights and the three mono weights (`EverfurFontFaceKey` on the tokens).
+ * A missing weight falls back along its chain: bold -> medium -> regular, monoBold -> monoMedium -> mono.
+ */
+type EverfurThemeFontFaceKey = 'regular' | 'medium' | 'bold' | 'mono' | 'monoMedium' | 'monoBold';
+/** The `fonts` map on the `theme` prop: a registered family name per face, any subset. */
+type EverfurThemeFontsInput = Readonly<Partial<Record<EverfurThemeFontFaceKey, string>>>;
+/** The `font_urls` map on the `theme` prop (web only): a brand-font URL per face, any subset. */
+type EverfurThemeFontUrlsInput = Readonly<Partial<Record<EverfurThemeFontFaceKey, string>>>;
+/**
+ * The client `theme` prop. Any shape is tolerated (unknown keys are ignored, malformed values are dropped); the
+ * named keys are the ones the resolver reads, in the console's snake_case with camelCase twins.
+ */
+interface EverfurThemeInput {
+    readonly display_name?: string;
+    readonly displayName?: string;
+    readonly logo_url?: string;
+    readonly logoUrl?: string;
+    /** The logo shown on the dark palette; absent, `logo_url` is shown on both. */
+    readonly logo_url_dark?: string;
+    readonly logoUrlDark?: string;
+    readonly primary_color?: string | number;
+    readonly primaryColor?: string | number;
+    readonly accent_color?: string | number;
+    readonly accentColor?: string | number;
+    /** The primary fill on the dark palette; absent, it is derived from `primary_color` (`deriveDarkVariant`). */
+    readonly primary_color_dark?: string | number;
+    readonly primaryColorDark?: string | number;
+    readonly accent_color_dark?: string | number;
+    readonly accentColorDark?: string | number;
+    /**
+     * `light` or `dark` pins the palette; `auto` follows the device's scheme. Absent (here and in the console), the
+     * theme is LIGHT, as Everfur's own apps are: the device scheme is never read unless someone chose `auto`.
+     */
+    readonly brightness?: string;
+    /** The console's name for `brightness` (`light`, `dark` or `auto`); `brightness` wins when both are set. */
+    readonly color_scheme?: string;
+    readonly colorScheme?: string;
+    readonly font_family?: string;
+    readonly fontFamily?: string;
+    readonly font_url?: string;
+    readonly fontUrl?: string;
+    /**
+     * The family per face. Two conventions, the same rendering on React Native and the web:
+     *   - one registered face per weight, the way the Everfur app maps weight to family (`Azeret-Regular`,
+     *     `Azeret-Medium`, `Azeret-Bold`, `AzeretMono-Regular`): a name no other weight of its group uses is a NAMED
+     *     face, rendered with no weight of its own (React Native) or at the normal weight (the web);
+     *   - one family for every weight (`Azeret`): a name shared across the weights of a group is a BASE family, and
+     *     every face takes its numeric weight on both hosts.
+     * A missing weight falls back along its chain (regular -> medium -> bold, mono -> monoMedium -> monoBold). The host
+     * registers the faces itself (the native font files, or a web `@font-face`) and passes the NAMES only: the SDK
+     * bundles no font. Beats `font_family` for the weights it names. On React Native, when the app's font registry can
+     * tell (expo-font's), a named face that is not registered falls back to the platform font at its weight, with a
+     * development warning.
+     */
+    readonly fonts?: EverfurThemeFontsInput;
+    /**
+     * Web only: the woff2 URL per face, loaded through the SDK's brand-font allow-list (a woff2 under `/fonts/`
+     * on the Everfur SDK CDN). A URL on any other origin is refused, so a host that serves its own licensed
+     * faces loads them with its own `@font-face` and passes `fonts` names only.
+     */
+    readonly font_urls?: EverfurThemeFontUrlsInput;
+    readonly fontUrls?: EverfurThemeFontUrlsInput;
+    readonly chat_placeholder?: string;
+    readonly chatPlaceholder?: string;
+    readonly placeholder?: string;
+    /** Typed for completeness; INERT on the client. The server decides the attribution from the plan. */
+    readonly hide_powered_by?: boolean;
+    readonly hidePoweredBy?: boolean;
+    /** `white`, `cream` or `subtle`. */
+    readonly surface_style?: string;
+    readonly surfaceStyle?: string;
+    /** `sharp`, `default` or `round`. */
+    readonly radius_scale?: string;
+    readonly radiusScale?: string;
+    /**
+     * The cap on the CHROME text tiers (headings, controls, chips, badges): 1 to 3.1, or 0 for none (the default,
+     * the tiers alone: headings 2, controls 1.8, chips 1.5, badges 1.3). Flowing content is never capped.
+     */
+    readonly accessibility_max_font_scale?: number | string;
+    readonly accessibilityMaxFontScale?: number | string;
+    /** Paint overrides at the named slots. */
+    readonly slots?: EverfurThemeSlotsInput;
+    /** Tolerated for any other key; ignored by the resolver. */
+    readonly [key: string]: unknown;
+}
+
+/** Recursively freeze a plain object/array tree in place and return it (typed as the input). */
+declare function deepFreeze<T>(value: T): T;
+/** Foreground text tokens; the semantic text ramp over surfaces. */
+interface EverfurTextColorTokens {
+    readonly primary: string;
+    readonly secondary: string;
+    readonly muted: string;
+    /** The composer placeholder ink (the Everfur app's `rgba(61,61,61,0.75)`, 5:1 on cream; a lifted twin on dark). */
+    readonly placeholder: string;
+    /** Text drawn on the brand fill (a compiled default; resolve recomputes onPrimary/onAccent via WCAG). */
+    readonly onBrand: string;
+    readonly metaCool: string;
+    /** The message timestamp and copy glyph under a bubble (the Everfur app's footer ink; a lifted twin on dark). */
+    readonly timestamp: string;
+}
+/** The Everfur color system: brand + surfaces + text ramp + semantic palette + component washes. */
+interface EverfurColorTokens {
+    readonly brand: string;
+    readonly brandSoft: string;
+    readonly brandSofter: string;
+    readonly brandBorder: string;
+    readonly borderHairlineGreen: string;
+    /** The brand at 55%: the edge of a floating card over the chat (the attachment popover, the Everfur app's). */
+    readonly brandBorderStrong: string;
+    /**
+     * The brand as TEXT or ICON ink. The resolver derives it from `brand`, pushed toward black (light palette) or
+     * white (dark palette) until it reads at 4.5:1 on every ground of the palette, so a light partner colour
+     * (yellow, mint, sky) keeps its hue as a fill and still reads as a label. Never use `brand` itself as ink.
+     */
+    readonly brandInk: string;
+    /**
+     * The ink of a TEXT LINK (citation titles, the disclaimer's links, "earlier messages", record document
+     * links): the `link` slot's text colour, else `accent`, guarded by the resolver at 4.5:1 on every ground a
+     * link sits on. `accent` is the link and highlight colour; this is its legible ink.
+     */
+    readonly linkInk: string;
+    readonly surface: string;
+    readonly surfaceCream: string;
+    readonly surfaceSubtle: string;
+    readonly background: string;
+    readonly borderRingCream: string;
+    /**
+     * The chat ground: the surface the thread, the empty state and the composer sit on. White by default (the
+     * Everfur app's shell); `surface_style` picks it. Kept apart from `surfaceCream` so choosing a ground never
+     * repaints the composer or the record cards.
+     */
+    readonly chatGround: string;
+    /** The composer pill's fill: the Everfur app's fixed cream, whatever `surface_style` picks for the ground. */
+    readonly composerFill: string;
+    /** The composer pill's edge: the brand at 75% (the Everfur app's, 5:1 on white). */
+    readonly composerBorder: string;
+    /** The colour of the soft lift under a floating control (the composer, the popover): the Everfur app's. */
+    readonly shadow: string;
+    readonly text: EverfurTextColorTokens;
+    /** The primary CTA fill (server-overridable via primary_color). Foreground is `onPrimary`. */
+    readonly primary: string;
+    /** WCAG-legible foreground for `primary` (computed by resolveTheme, never passed through). */
+    readonly onPrimary: string;
+    /** The user/CTA accent fill (server-overridable via accent_color). Foreground is `onAccent`. */
+    readonly accent: string;
+    /** WCAG-legible foreground for `accent` (computed by resolveTheme). */
+    readonly onAccent: string;
+    /** The 0.5px bubble edge (a lightened brand / success green for the default). */
+    readonly accentEdge: string;
+    readonly success: string;
+    readonly danger: string;
+    readonly errorRed: string;
+    readonly warningStrong: string;
+    readonly cautionAccent: string;
+    readonly riskConcern: string;
+    /**
+     * The three feedback thumbs under an assistant reply, the Everfur app's Figma strokes: `up` (helpful) green,
+     * `neutral` amber, `down` (not helpful) red. The stroke at rest and the fill once recorded.
+     */
+    readonly sentiment: {
+        readonly up: string;
+        readonly neutral: string;
+        readonly down: string;
+    };
+    readonly badgeBgPositive: string;
+    readonly badgeBgCaution: string;
+    readonly badgeBgCritical: string;
+    readonly badgeBgNeutral: string;
+    /** user bubble = accent fill; assistant bubble = bare surface (the mobile/Flutter asymmetry). */
+    readonly bubbleUser: string;
+    readonly bubbleAssistant: string;
+    readonly skeleton: string;
+    readonly scanButtonPink: string;
+    readonly checkupCardLowRiskBg: string;
+    readonly checkupCardConcernBg: string;
+}
+/** Spacing scale (dp). */
+interface EverfurSpaceTokens {
+    readonly xs: number;
+    readonly sm: number;
+    readonly md: number;
+    readonly lg: number;
+    readonly xl: number;
+    readonly xxl: number;
+}
+/** Corner-radius scale (dp); `pill` is an effectively-infinite radius. */
+interface EverfurRadiusTokens {
+    readonly tile: number;
+    readonly xs: number;
+    readonly sm: number;
+    readonly md: number;
+    readonly lg: number;
+    readonly xl: number;
+    readonly pill: number;
+}
+interface EverfurTypeSizeTokens {
+    readonly nano: number;
+    readonly small: number;
+    readonly micro: number;
+    readonly tiny: number;
+    readonly caption: number;
+    readonly bodyTight: number;
+    readonly body: number;
+    readonly subtitle: number;
+    readonly heading: number;
+    readonly verdict: number;
+}
+/** Line-height multipliers (applied to a size to derive an absolute lineHeight). */
+interface EverfurLineHeightTokens {
+    readonly tight: number;
+    readonly snug: number;
+    readonly normal: number;
+    readonly relaxed: number;
+}
+/**
+ * RN-assignable font-weight literals. Typed as the exact string literals we ship (not bare `string`) so a
+ * consumer can spread a weight token straight into a `Text` style: React Native's `TextStyle['fontWeight']`
+ * accepts these, but rejects `string`. Kept framework-free (no react-native import) to hold the client layer's
+ * no-framework boundary - these three literals are a subset of RN's fontWeight union.
+ */
+type EverfurFontWeight = '400' | '500' | '700';
+/** RN fontWeight tokens. */
+interface EverfurWeightTokens {
+    readonly regular: EverfurFontWeight;
+    readonly medium: EverfurFontWeight;
+    readonly bold: EverfurFontWeight;
+}
+interface EverfurLetterSpacingTokens {
+    readonly eyebrow: number;
+    readonly monoWide: number;
+    readonly headerBrand: number;
+    readonly tight: number;
+}
+/**
+ * The faces a theme names: the three text weights and the three mono weights (the Everfur app registers
+ * `AzeretMono-Regular`, `-Medium` and `-Bold`). A missing weight falls back along its chain: bold -> medium ->
+ * regular, monoBold -> monoMedium -> mono.
+ */
+type EverfurFontFaceKey = 'regular' | 'medium' | 'bold' | 'mono' | 'monoMedium' | 'monoBold';
+/**
+ * The text-scale tiers of the Everfur app (`fontScaling.ts`): how far a class of text may follow the user's text
+ * size. Flowing `content` (message bodies, card bodies, list rows) is never capped; the bounded chrome is:
+ * `heading` 2x, `control` (buttons) 1.8x, `compact` (chips, pills, inline meta) 1.5x, `badge` 1.3x.
+ */
+type EverfurTextScaleTier = 'content' | 'heading' | 'control' | 'compact' | 'badge';
+/**
+ * The cap of each tier, React Native's `maxFontSizeMultiplier` semantics: 0 means no maximum. The Everfur app's
+ * values, verbatim. A tenant's `accessibility_max_font_scale` may lower the chrome tiers further, never content.
+ */
+declare const TEXT_SCALE_TIER_CAPS: Readonly<Record<EverfurTextScaleTier, number>>;
+/** The family rendered at each face. Every entry is populated (the compiled default is the platform font). */
+type EverfurFontFamilies = Readonly<Record<EverfurFontFaceKey, string>>;
+/**
+ * Typography tokens. `families` is the family per face; a branding sets them through `fonts` (one registered
+ * face per weight, the Everfur app's own scheme) or the legacy single `font_family`, else the platform font.
+ * `family` / `mono` / `fontUrl` are aliases of the regular and mono entries, kept for every reader of the
+ * pre-`families` shape. A surface never reads these raw: `face(theme, weight)` (typeStyle.ts) picks the
+ * family and decides whether a numeric `fontWeight` belongs beside it.
+ */
+interface EverfurTypeTokens {
+    /** Alias of `families.regular`. */
+    readonly family: string;
+    /** Alias of `families.mono`. */
+    readonly mono: string;
+    /** Alias of `fontUrls.regular`; null unless an override supplies an https URL. */
+    readonly fontUrl: string | null;
+    readonly families: EverfurFontFamilies;
+    /**
+     * Per face: true when `families[face]` is a NAMED face from a `fonts` map (the weight is baked into the
+     * registered face, so `face()` sets no `fontWeight`); false when it is a base family (`font_family` or the
+     * platform font) that carries every weight and takes the numeric `weight` token.
+     */
+    readonly namedFaces: Readonly<Record<EverfurFontFaceKey, boolean>>;
+    /** The brand-font URL per face (web only, `font_urls` / `font_url`); absent or null when none applies. */
+    readonly fontUrls: Readonly<Partial<Record<EverfurFontFaceKey, string | null>>>;
+    /**
+     * The type scale. On the web it ALREADY carries `scale` (CSS px do not follow the user's text setting on their
+     * own); on React Native it is the authored size, which the platform scales natively up to `maxScale`.
+     */
+    readonly size: EverfurTypeSizeTokens;
+    readonly lineHeight: EverfurLineHeightTokens;
+    readonly weight: EverfurWeightTokens;
+    readonly letterSpacing: EverfurLetterSpacingTokens;
+    /**
+     * `size` per text-scale tier (`EverfurTextScaleTier`). On the web each tier carries the user's scale up to that
+     * tier's cap (`content` is `size` itself, uncapped); on React Native every tier is the authored `size` and the
+     * platform scales it natively under the tier's `maxFontSizeMultiplier` (`scaleCaps`, applied by the SDK's `Text`).
+     */
+    readonly tierSizes: Readonly<Record<'content' | 'heading' | 'control' | 'compact' | 'badge', EverfurTypeSizeTokens>>;
+    /** The end user's effective text scale (their device setting, floored at `TEXT_SCALE_FLOOR`); 1 when unknown. */
+    readonly scale: number;
+    /**
+     * The tenant's cap on the CHROME tiers (`accessibility_max_font_scale`): 0 means none (the default), so the
+     * tier caps alone bound headings, controls, chips and badges. Flowing content is never capped.
+     */
+    readonly maxScale: number;
+    /**
+     * The effective cap of each tier (`EverfurTextScaleTier`): the tier's own cap, lowered by `maxScale` for the
+     * chrome tiers; 0 means none (React Native's `maxFontSizeMultiplier` semantics).
+     */
+    readonly scaleCaps: Readonly<Record<'content' | 'heading' | 'control' | 'compact' | 'badge', number>>;
+}
+interface EverfurSpringToken {
+    readonly damping: number;
+    readonly stiffness: number;
+}
+interface EverfurMotionDurationTokens {
+    readonly instant: number;
+    readonly fast: number;
+    readonly normal: number;
+    readonly slow: number;
+}
+/** Motion tokens. Under reduced-motion, resolveTheme collapses durations to 0 and stiffens the spring. */
+interface EverfurMotionTokens {
+    readonly duration: EverfurMotionDurationTokens;
+    readonly spring: {
+        readonly gentle: EverfurSpringToken;
+    };
+    /**
+     * The Everfur app's curves as CSS `cubic-bezier()` values: `standard` for most transitions, `emphasized` for an
+     * entrance that should draw the eye, `exit` for a leave. `EASING_CURVES` holds the same curves as numbers.
+     */
+    readonly easing: {
+        readonly standard: string;
+        readonly emphasized: string;
+        readonly exit: string;
+    };
+    /** true when the resolved theme has collapsed motion (AccessibilityInfo reduced-motion). */
+    readonly reducedMotion: boolean;
+}
+/** Non-visual identity + partner copy carried on the theme (server display_name/logo_url/placeholder overlay). */
+interface EverfurThemeMeta {
+    readonly displayName: string;
+    readonly logoUrl: string | null;
+    /** Server-overridable composer placeholder (chat_placeholder/placeholder); null keeps Everfur's neutral default. */
+    readonly placeholder: string | null;
+    /** White-label switch (hide_powered_by): drop the "powered by everfur" attribution. Default false (shown). */
+    readonly hidePoweredBy: boolean;
+}
+/**
+ * The frozen, never-null theme the rn layer renders. Read a token as `theme.color.brand`,
+ * `theme.space.md`, `theme.type.size.body`, `theme.radius.lg`, `theme.motion.duration.fast`; a slot's paint
+ * as `theme.slots.userBubble?.backgroundColor`.
+ */
+interface EverfurTheme {
+    readonly brightness: 'light' | 'dark';
+    /** true when the user asked for more contrast (`prefers-contrast: more`) and the palette was derived for it. */
+    readonly highContrast: boolean;
+    readonly meta: EverfurThemeMeta;
+    readonly color: EverfurColorTokens;
+    readonly space: EverfurSpaceTokens;
+    readonly radius: EverfurRadiusTokens;
+    readonly type: EverfurTypeTokens;
+    readonly motion: EverfurMotionTokens;
+    /** Paint overrides at the named slots (empty by default); each text colour is contrast-guarded. */
+    readonly slots: EverfurThemeSlots;
+}
+/**
+ * The tenant's chrome cap when it sets none (`accessibility_max_font_scale`): 0, no cap beyond the tiers of
+ * `TEXT_SCALE_TIER_CAPS`, the Everfur app's own policy.
+ */
+declare const DEFAULT_MAX_FONT_SCALE = 0;
+/** The RN token that means "the platform font"; every face of the compiled default. */
+declare const SYSTEM_FONT_FAMILY = "System";
+/**
+ * The generic mono keyword of the compiled default. React Native on iOS has no family of that name, so the
+ * React Native host maps it per platform (Menlo on iOS); the web host maps it to its mono stack.
+ */
+declare const SYSTEM_MONO_FAMILY = "monospace";
+/** A cubic-bezier as its four control values (`[x1, y1, x2, y2]`). */
+type EverfurEasingCurve = readonly [number, number, number, number];
+/** The Everfur app's easing curves (`src/motion/tokens.ts`), as numbers; `motion.easing` holds them as CSS. */
+declare const EASING_CURVES: Readonly<Record<'standard' | 'emphasized' | 'exit', EverfurEasingCurve>>;
+/** `cubic-bezier(x1, y1, x2, y2)` for a curve. */
+declare function cssCubicBezier(curve: EverfurEasingCurve): string;
+/** The compiled LIGHT default (deeply frozen). */
+declare const EVERFUR_LIGHT: EverfurTheme;
+/** The compiled DARK default (deeply frozen). */
+declare const EVERFUR_DARK: EverfurTheme;
+
+interface ClientBranding {
+    readonly displayName: string | null;
+    /** normalized (https-hardened downstream) logo URL */
+    readonly logoUrl: string | null;
+    /** normalized color string (#RRGGBB or rgba(...)) or null */
+    readonly primaryColor: string | null;
+    readonly accentColor: string | null;
+    /**
+     * `light` or `dark` pins the palette; `auto` follows the device's scheme (an explicit opt-in). null (absent)
+     * resolves to LIGHT, as Everfur's own apps render. Read from `brightness`, or its console alias `color_scheme`
+     * (`colorScheme`).
+     */
+    readonly brightness: 'light' | 'dark' | 'auto' | null;
+    readonly fontFamily: string | null;
+    readonly fontUrl: string | null;
+    /**
+     * fonts: one registered family per face (`regular` / `medium` / `bold` / `mono` / `monoMedium` / `monoBold`),
+     * any subset. A name used by one face of its group only is a named face, rendered without a synthetic
+     * `fontWeight`; a name repeated across the weights of a group is a base family and takes the numeric weights.
+     * Absent/null names none (the base families stand).
+     */
+    readonly fonts?: Readonly<Partial<Record<EverfurFontFaceKey, string>>> | null;
+    /** font_urls: the brand-font URL per face (web only), any subset; hardened https-only downstream. */
+    readonly fontUrls?: Readonly<Partial<Record<EverfurFontFaceKey, string>>> | null;
+    /** composer placeholder override (chat_placeholder/placeholder); null keeps the base. */
+    readonly placeholder: string | null;
+    /**
+     * white-label switch (hide_powered_by): hide the powered-by attribution. null = unset (keep the base). Honoured
+     * from SERVER branding only: `resolveTheme` ignores it on the client override (attribution is server-only).
+     */
+    readonly hidePoweredBy: boolean | null;
+    /** primary_color_dark: the primary fill used when the resolved palette is dark. Absent/null derives one. */
+    readonly primaryColorDark?: string | null;
+    /** accent_color_dark: the accent fill used when the resolved palette is dark. Absent/null derives one. */
+    readonly accentColorDark?: string | null;
+    /**
+     * surface_style: which compiled surface the chat ground (`chatGround`) uses. Absent/null keeps the palette's
+     * white ground (the Everfur app's shell). The composer and the record cards keep their cream either way.
+     */
+    readonly surfaceStyle?: SurfaceStyle | null;
+    /** radius_scale: scales the corner radii (the pill radius is never scaled). Absent/null keeps the palette radii. */
+    readonly radiusScale?: RadiusScale | null;
+    /** logo_url_dark: the logo shown on the dark palette. Absent/null keeps logoUrl on both palettes. */
+    readonly logoUrlDark?: string | null;
+    /** slots: paint overrides at the named slots (schema 2). Absent/null paints none. */
+    readonly slots?: EverfurThemeSlots | null;
+    /**
+     * accessibility_max_font_scale: the tenant's cap on the CHROME text tiers (headings, controls, chips, badges),
+     * 1..3.1, or 0 for none. Flowing content is never capped. Absent/null keeps the default (0, the tiers alone).
+     */
+    readonly accessibilityMaxFontScale?: number | null;
+    /**
+     * locked_fields: the wire names the tenant keeps server-wins (schema 2): a field, `slots` (every slot) or
+     * `slots.<name>` (one slot); the wire also lists `hide_powered_by`, which is locked whether listed or not.
+     * Meaningful on SERVER branding only; ignored on the client override. Absent/null locks nothing beyond the
+     * attribution.
+     */
+    readonly lockedFields?: readonly ThemeLockName[] | null;
+    /**
+     * schema_version: the wire version the branding was written for. null when absent (schema 1); 0 when present but
+     * not a positive integer. A version this SDK does not know (`THEME_SCHEMA_VERSIONS`) drops the server branding.
+     */
+    readonly schemaVersion?: number | null;
+}
+/** The compiled surface a branding may pick for the chat ground (`surface_style`). */
+type SurfaceStyle = 'white' | 'cream' | 'subtle';
+/** The corner-radius scale a branding may pick (`radius_scale`). */
+type RadiusScale = 'sharp' | 'default' | 'round';
+/**
+ * The wire names a tenant may list in `locked_fields` (every cosmetic field). `hide_powered_by` is not listed:
+ * it is server-wins unconditionally, so locking it is meaningless.
+ */
+declare const LOCKABLE_THEME_FIELDS: readonly ["display_name", "logo_url", "logo_url_dark", "primary_color", "accent_color", "primary_color_dark", "accent_color_dark", "brightness", "color_scheme", "font_family", "font_url", "fonts", "font_urls", "chat_placeholder", "surface_style", "radius_scale", "accessibility_max_font_scale", "slots"];
+type LockableThemeField = (typeof LOCKABLE_THEME_FIELDS)[number];
+/** The `locked_fields` key that locks one slot (`slots.<name>`), as EFBackend branding_slots.py emits it. */
+declare const SLOT_LOCK_PREFIX = "slots.";
+type SlotLockName = `${typeof SLOT_LOCK_PREFIX}${EverfurThemeSlotName}`;
+/** Everything `locked_fields` may name: a cosmetic field, one slot, or the (always locked) attribution. */
+type ThemeLockName = LockableThemeField | SlotLockName | 'hide_powered_by';
+/** The branding wire versions this SDK reads: 1 (absent on the wire) and 2 (the 18 Sep 2026 fields). */
+declare const THEME_SCHEMA_VERSIONS: readonly number[];
+/**
+ * true when every field is null (no config) - treated by callers as "absent". The version stamp alone is not a
+ * value: a branding that carries only `schema_version` is empty.
+ */
+declare function isEmptyBranding(b: ClientBranding): boolean;
+/** true when the branding is absent or written for a wire version this SDK knows. */
+declare function isKnownBrandingSchema(b: ClientBranding | null): boolean;
+/** The names a server branding keeps server-wins: its `locked_fields`, plus the attribution always. */
+declare function lockedFieldsOf(b: ClientBranding | null): ReadonlySet<string>;
+/**
+ * Parse an untrusted branding blob (from the entitlements render_hints, or the client `theme` prop) into a
+ * normalized `ClientBranding`. Accepts BOTH snake_case and camelCase keys. Returns null when the input is not
+ * an object OR when the result is empty (all fields null) - callers read null as "no config" (fail-closed to
+ * the compiled default). Never throws.
+ */
+declare function parseClientBranding(json: unknown): ClientBranding | null;
+/** The largest cap a tenant may set on the chrome tiers: iOS's largest accessibility text size (AX5, 310%). */
+declare const MAX_FONT_SCALE_CEILING = 3.1;
+/**
+ * Return the URL only if it is an https URL with no embedded whitespace, else null (security invariant:
+ * https-only; rejects http:, javascript:, data:, etc.). Uses a protocol-locked regex rather than the URL
+ * constructor so it is portable + total on React Native (whose URL global is incomplete) and never throws.
+ */
+declare function hardenHttpsUrl(url: string | null): string | null;
+
+export { guardSlotContrast as $, THEME_SLOT_NAMES as A, EASING_CURVES as B, type ClientBranding as C, DEFAULT_MAX_FONT_SCALE as D, type EverfurThemeInput as E, EVERFUR_DARK as F, EVERFUR_LIGHT as G, type EverfurEasingCurve as H, type EverfurTextScaleTier as I, type LockableThemeField as J, SLOT_LOCK_PREFIX as K, LOCKABLE_THEME_FIELDS as L, MAX_FONT_SCALE_CEILING as M, SLOT_MIN_BORDER_CONTRAST as N, SLOT_MIN_CONTRAST as O, SYSTEM_FONT_FAMILY as P, SYSTEM_MONO_FAMILY as Q, type RadiusScale as R, type SurfaceStyle as S, THEME_SLOT_KEYS as T, type SlotGrounds as U, type SlotLockName as V, TEXT_SCALE_TIER_CAPS as W, THEME_SCHEMA_VERSIONS as X, type ThemeLockName as Y, cssCubicBezier as Z, deepFreeze as _, type EverfurTheme as a, hardenHttpsUrl as a0, isEmptyBranding as a1, isKnownBrandingSchema as a2, lockedFieldsOf as a3, mergeThemeSlots as a4, parseClientBranding as a5, parseThemeSlots as a6, type EverfurFontWeight as b, type EverfurFontFaceKey as c, type EverfurColorTokens as d, type EverfurFontFamilies as e, type EverfurLetterSpacingTokens as f, type EverfurLineHeightTokens as g, type EverfurMotionDurationTokens as h, type EverfurMotionTokens as i, type EverfurRadiusTokens as j, type EverfurSpaceTokens as k, type EverfurSpringToken as l, type EverfurTextColorTokens as m, type EverfurThemeFontFaceKey as n, type EverfurThemeFontUrlsInput as o, type EverfurThemeFontsInput as p, type EverfurThemeMeta as q, type EverfurThemeSlot as r, type EverfurThemeSlotInput as s, type EverfurThemeSlotKey as t, type EverfurThemeSlotName as u, type EverfurThemeSlots as v, type EverfurThemeSlotsInput as w, type EverfurTypeSizeTokens as x, type EverfurTypeTokens as y, type EverfurWeightTokens as z };

package/dist/callCopy-DoQKG3-L.d.cts

@@ -0,0 +1,40 @@
+/** The phases the in-app call surface moves through. The consumer app's `CallPhase`, verbatim. */
+type VetCallPhase = 'joining' | 'joined' | 'left' | 'error';
+/**
+ * Refuses anything that is not an https room.
+ *
+ * NEVER THROWS and never echoes the input: an unparseable value returns false rather than raising, because
+ * the caller is already on a failure path when it asks.
+ */
+declare function isSafeRoomUrl(url: string): boolean;
+/**
+ * The whole credential floor: an https room AND a non-empty join token. The call surface renders nothing and
+ * creates no call object unless this is true.
+ */
+declare function isUsableRoomCredential(roomUrl: string, token: string): boolean;
+
+/** The consult length the lobby quotes, in minutes. everfur-mobile-2026-7 televetTime.ts:85 `CONSULT_MINUTES`. */
+declare const VET_CALL_CONSULT_MINUTES = 10;
+declare const VET_CALL_COPY: Readonly<{
+    /** Controls, shared by the lobby and the live call. */
+    muteCta: "Mute";
+    unmuteCta: "Unmute";
+    cameraOffCta: "Camera off";
+    cameraOnCta: "Camera on";
+    leaveCta: "Leave";
+    /** The lobby: the member is in the room and the clinician is not. */
+    lobbyTitleNoName: "Your vet is joining";
+    lobbySubtitle: "Usually under a minute";
+    lobbyPrepLabel: "WHILE YOU WAIT";
+    lobbyPrepNoPet: "Have your pet nearby and somewhere well lit.";
+    /** `{name}` is DATA from the consult, never a key. Absent, `lobbyTitleNoName` is used instead. */
+    lobbyTitle: (clinicianName: string | null | undefined) => string;
+    /** `{pet}` is DATA from the roster. Absent, the pet-free form is used instead. */
+    lobbyPrep: (petName: string | null | undefined) => string;
+    /** `{n}` is `VET_CALL_CONSULT_MINUTES`, never a hardcoded number. */
+    lobbyDuration: (minutes: number) => string;
+    /** The consumer app's `visit.joinFailedReason` (:735), shown when the call object errors. */
+    joinFailedReason: "That did not open. Try again.";
+}>;
+
+export { VET_CALL_CONSULT_MINUTES as V, VET_CALL_COPY as a, type VetCallPhase as b, isUsableRoomCredential as c, isSafeRoomUrl as i };

package/dist/callCopy-DoQKG3-L.d.ts

@@ -0,0 +1,40 @@
+/** The phases the in-app call surface moves through. The consumer app's `CallPhase`, verbatim. */
+type VetCallPhase = 'joining' | 'joined' | 'left' | 'error';
+/**
+ * Refuses anything that is not an https room.
+ *
+ * NEVER THROWS and never echoes the input: an unparseable value returns false rather than raising, because
+ * the caller is already on a failure path when it asks.
+ */
+declare function isSafeRoomUrl(url: string): boolean;
+/**
+ * The whole credential floor: an https room AND a non-empty join token. The call surface renders nothing and
+ * creates no call object unless this is true.
+ */
+declare function isUsableRoomCredential(roomUrl: string, token: string): boolean;
+
+/** The consult length the lobby quotes, in minutes. everfur-mobile-2026-7 televetTime.ts:85 `CONSULT_MINUTES`. */
+declare const VET_CALL_CONSULT_MINUTES = 10;
+declare const VET_CALL_COPY: Readonly<{
+    /** Controls, shared by the lobby and the live call. */
+    muteCta: "Mute";
+    unmuteCta: "Unmute";
+    cameraOffCta: "Camera off";
+    cameraOnCta: "Camera on";
+    leaveCta: "Leave";
+    /** The lobby: the member is in the room and the clinician is not. */
+    lobbyTitleNoName: "Your vet is joining";
+    lobbySubtitle: "Usually under a minute";
+    lobbyPrepLabel: "WHILE YOU WAIT";
+    lobbyPrepNoPet: "Have your pet nearby and somewhere well lit.";
+    /** `{name}` is DATA from the consult, never a key. Absent, `lobbyTitleNoName` is used instead. */
+    lobbyTitle: (clinicianName: string | null | undefined) => string;
+    /** `{pet}` is DATA from the roster. Absent, the pet-free form is used instead. */
+    lobbyPrep: (petName: string | null | undefined) => string;
+    /** `{n}` is `VET_CALL_CONSULT_MINUTES`, never a hardcoded number. */
+    lobbyDuration: (minutes: number) => string;
+    /** The consumer app's `visit.joinFailedReason` (:735), shown when the call object errors. */
+    joinFailedReason: "That did not open. Try again.";
+}>;
+
+export { VET_CALL_CONSULT_MINUTES as V, VET_CALL_COPY as a, type VetCallPhase as b, isUsableRoomCredential as c, isSafeRoomUrl as i };