@everfur/sdk 0.1.0 → 0.3.0

package/dist/entitlementRepository-DKdXFgTo.d.cts

@@ -0,0 +1,698 @@
+import { E as EverfurError } from './EverfurResult-DN9pL2Ab.cjs';
+import { R as RequestFunnel } from './requestFunnel-L-BQfi0z.cjs';
+import { A as AuthContext } from './identity-DI4eVx9S.cjs';
+import { E as EntitlementDecision } from './resolve-D4Ywz5OS.cjs';
+
+/** 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;
+/**
+ * Overlay `b` onto `base`, field by field: a non-null branding field WINS; a null field KEEPS the base. A
+ * valid brightness re-selects the matching compiled palette (light/dark); an invalid/absent brightness leaves
+ * the base palette untouched. Slots merge per slot, per key. Returns a NEW deeply-frozen theme; `base` and `b`
+ * are never mutated.
+ *
+ * The name is historical (the server was once the only overlay); `resolveTheme` applies it twice, server then
+ * client, which is how the client wins per field. NOTE: foreground legibility (onPrimary/onAccent, the slot
+ * guard) and URL hardening are applied by `resolveTheme`, the total entry point. Call this directly only when
+ * you will finalize the result yourself.
+ */
+declare function withServerBranding(base: EverfurTheme, b: ClientBranding | null): EverfurTheme;
+/**
+ * Inputs to the total theme resolve. All optional; `resolveTheme(undefined)` yields the compiled Everfur
+ * default. Merge order: compiled default <- server branding (render_hints) <- client theme prop, per field, with
+ * the tenant's locked fields and the attribution kept from the server (see `resolveTheme`).
+ */
+interface ResolveThemeInput {
+    /** Server-driven branding from the live entitlements render_hints (the tenant's console branding). */
+    readonly branding?: ClientBranding | null;
+    /**
+     * The clamped client `theme` prop. It WINS per cosmetic field over the server branding, except the fields the
+     * server lists in `locked_fields`. Its hidePoweredBy is IGNORED: whether the Everfur attribution shows is
+     * decided by server branding alone.
+     */
+    readonly clientOverride?: ClientBranding | null;
+    /**
+     * The device color scheme (useColorScheme / `prefers-color-scheme`). Read ONLY when the settled brightness is
+     * `auto` (an explicit opt-in); with no brightness set anywhere the theme is light, as Everfur's own apps are.
+     */
+    readonly colorScheme?: 'light' | 'dark' | null;
+    /** AccessibilityInfo reduced-motion / `prefers-reduced-motion`: collapses the motion tokens. */
+    readonly reducedMotion?: boolean;
+    /**
+     * The user's text scale as the host reads it (React Native: `PixelRatio.getFontScale()`; the browser: the
+     * browser's default font size over 16px). Floored at `TEXT_SCALE_FLOOR`; absent or junk reads as 1. Flowing
+     * content follows it uncapped; each chrome tier follows it up to that tier's cap (`type.scaleCaps`).
+     */
+    readonly textScale?: number;
+    /**
+     * Multiply the type sizes by the effective scale, per tier (`type.size` for content, `type.tierSizes` for every
+     * tier). A browser host passes true (CSS px do not follow the user's setting on their own); a React Native host
+     * leaves it false and lets the platform scale every Text natively, capped per tier by `maxFontSizeMultiplier`.
+     */
+    readonly scaleTypeSizes?: boolean;
+    /** The user asked for more contrast (`prefers-contrast: more`): the palette is derived by `deriveHighContrast`. */
+    readonly highContrast?: boolean;
+    /**
+     * The family the platform's generic mono keyword (`SYSTEM_MONO_FAMILY`) maps to on this host. React Native on iOS
+     * has no family named `monospace` (a Text asking for it renders proportional, and the legacy architecture
+     * red-boxes in development), so the React Native host passes `Menlo` there. Applied to the compiled default mono
+     * only: a partner's own mono face is never touched. Absent or blank, the keyword stands (the web maps it to its
+     * mono stack in CSS).
+     */
+    readonly platformMonoFamily?: string;
+    /**
+     * Whether a family name is registered with the platform, when the host can tell: true or false, else null. A
+     * NAMED face (one per-weight name, rendered without a weight) that the host reports unregistered falls back to
+     * the platform font of its group WITH its numeric weight, so medium and bold survive instead of every weight
+     * collapsing to the platform's regular. Only named faces are asked about; a throw reads as null.
+     */
+    readonly isFontRegistered?: (family: string) => boolean | null;
+}
+/** The smallest effective text scale the resolver will report (a device may ask for less; the surfaces stop here). */
+declare const TEXT_SCALE_FLOOR = 0.5;
+/**
+ * Resolve the final, legible, deeply-frozen theme. Never throws, never returns null/transparent.
+ *
+ * PRECEDENCE (per field, owner decision of 18 September 2026; the same rule EFBackend render_hint_fold states):
+ * a field in `locked_fields` (plus `hide_powered_by` always) is server-wins; every other cosmetic field is
+ * client-wins.
+ *   - A server branding with an unknown `schema_version` is dropped whole (default plus client theme).
+ *   - `hide_powered_by`, and every name the server lists in `locked_fields`, are SERVER-WINS: the client's value
+ *     for such a field is discarded before the merge, so the server's value or the compiled default stands.
+ *     `slots` in the list locks every slot; `slots.<name>` locks one.
+ *   - Every other cosmetic field is CLIENT-WINS: the client `theme` prop overrides the console value, and the
+ *     console fills the fields the prop leaves unset. Brightness is settled the same way; set nowhere, it is
+ *     LIGHT (owner decision OD28: Everfur's own apps are light-only), and `auto` follows the device scheme.
+ *   - Slots overlay slot by slot (a named slot replaces the one below it whole) in the same order, after the
+ *     field precedence.
+ * Then the total-resolve guarantees: onPrimary/onAccent via WCAG, the slot contrast guard, https-only logo/font
+ * URLs, a non-empty displayName, the text scale (floored; tiered caps on the chrome), motion collapsed under reduced
+ * motion, and the high-contrast derivation when the user asked for it.
+ */
+declare function resolveTheme(input?: ResolveThemeInput): EverfurTheme;
+/**
+ * The console's preview helper: resolve a draft branding exactly as the device would, from the raw shapes (the
+ * partner's `theme` prop and the server-shaped branding object the console is about to publish), with the device
+ * inputs of the preview. Pure and total: any shape is tolerated, nothing throws.
+ */
+declare function previewTheme(input: EverfurThemeInput | null, hints: unknown, options?: Omit<ResolveThemeInput, 'branding' | 'clientOverride'>): EverfurTheme;
+
+/** The conditional-GET endpoint (SPEC-00 §5.3). Relative; the transport prefixes the resolved base URL. */
+declare const ENTITLEMENTS_PATH = "/widget/v1/entitlements";
+/**
+ * The settled outcome of one entitlement fetch. `updated` carries a fresh verdict + the cadence to re-poll on;
+ * `notModified` means the cached verdict still holds; `failed` carries a normalized error and means keep-last.
+ */
+type EntitlementResolution = {
+    readonly kind: 'updated';
+    readonly revision: number;
+    readonly region: string;
+    readonly ttlSeconds: number;
+    readonly decisions: readonly EntitlementDecision[];
+    /**
+     * Server-driven branding parsed from the SAME 200 body's render_hints (orthogonal to capabilities).
+     * null when absent or unparseable (fail-closed -> the compiled Everfur default theme). OPTIONAL so a
+     * hand-built resolution (tests / injected resolve) need not supply it.
+     */
+    readonly branding?: ClientBranding | null;
+} | {
+    readonly kind: 'notModified';
+} | {
+    readonly kind: 'failed';
+    readonly error: EverfurError;
+};
+interface FetchEntitlementsArgs {
+    /** The revision we last stored; echoed as If-None-Match so an unchanged verdict returns 304. */
+    readonly cachedRevision?: number | null;
+    /** Optional region hint; forwarded as ?region. */
+    readonly region?: string;
+}
+/**
+ * Fetch the server-resolved entitlement verdict once. Never throws: a 304, a domain error, a network reject,
+ * and a malformed body all SETTLE to an EntitlementResolution. Fail-closed on every non-`updated` path.
+ */
+declare function fetchEntitlements(auth: AuthContext, args?: FetchEntitlementsArgs, funnel?: RequestFunnel): Promise<EntitlementResolution>;
+
+export { TEXT_SCALE_FLOOR as $, THEME_SLOT_NAMES as A, previewTheme as B, type ClientBranding as C, DEFAULT_MAX_FONT_SCALE as D, type EverfurFontWeight as E, EASING_CURVES as F, ENTITLEMENTS_PATH as G, EVERFUR_DARK as H, EVERFUR_LIGHT as I, type EntitlementResolution as J, type EverfurEasingCurve as K, type EverfurTextScaleTier as L, type FetchEntitlementsArgs as M, LOCKABLE_THEME_FIELDS as N, type LockableThemeField as O, MAX_FONT_SCALE_CEILING as P, type ResolveThemeInput as Q, type RadiusScale as R, type SurfaceStyle as S, THEME_SLOT_KEYS as T, SLOT_LOCK_PREFIX as U, SLOT_MIN_BORDER_CONTRAST as V, SLOT_MIN_CONTRAST as W, SYSTEM_FONT_FAMILY as X, SYSTEM_MONO_FAMILY as Y, type SlotGrounds as Z, type SlotLockName as _, type EverfurTheme as a, TEXT_SCALE_TIER_CAPS as a0, THEME_SCHEMA_VERSIONS as a1, type ThemeLockName as a2, cssCubicBezier as a3, deepFreeze as a4, fetchEntitlements as a5, guardSlotContrast as a6, hardenHttpsUrl as a7, isEmptyBranding as a8, isKnownBrandingSchema as a9, lockedFieldsOf as aa, mergeThemeSlots as ab, parseClientBranding as ac, parseThemeSlots as ad, resolveTheme as ae, withServerBranding as af, type EverfurFontFaceKey as b, type EverfurThemeInput 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 };