@vectoriox/iox-ui 5.13.1 → 5.15.0

package/design-core/index.d.ts

@@ -882,7 +882,7 @@ declare const SPEC_SPRINGS: {
     };
 };
 declare const SPEC_FONTS: {
-    readonly Inter: "Inter:wght@400;500;600;700";
+    readonly Inter: "Inter:wght@300;400;500;600;700";
     readonly "Inter Tight": "Inter+Tight:wght@500;600;700";
     readonly Manrope: "Manrope:wght@400;500;600;700";
     readonly "IBM Plex Sans": "IBM+Plex+Sans:wght@400;500;600;700";
@@ -897,12 +897,21 @@ declare const SPEC_FONTS: {
     readonly Figtree: "Figtree:wght@400;500;600;700;800";
     readonly "Google Sans Flex": "Google+Sans+Flex:wght@400;500;600;700";
     readonly "Bricolage Grotesque": "Bricolage+Grotesque:opsz,wght@12..96,500;12..96,700";
-    readonly Nunito: "Nunito:wght@400;600;700;800";
+    readonly Nunito: "Nunito:wght@300;400;600;700;800";
     readonly "DM Sans": "DM+Sans:wght@400;500;700";
     readonly Archivo: "Archivo:wght@400;500;700";
     readonly "Archivo Black": "Archivo+Black";
     readonly Syne: "Syne:wght@600;700;800";
     readonly "Space Mono": "Space+Mono:wght@400;700";
+    readonly Poppins: "Poppins:ital,wght@0,300;0,400;0,500;0,600;0,700;1,400";
+    readonly Roboto: "Roboto:ital,wght@0,300;0,400;0,500;0,700;1,400";
+    readonly Lato: "Lato:ital,wght@0,300;0,400;0,700;1,400";
+    readonly "Open Sans": "Open+Sans:ital,wght@0,300;0,400;0,600;0,700;1,400";
+    readonly Montserrat: "Montserrat:ital,wght@0,300;0,400;0,500;0,600;0,700;1,400";
+    readonly Raleway: "Raleway:wght@300;400;500;600;700";
+    readonly "Playfair Display": "Playfair+Display:ital,wght@0,400;0,500;0,700;1,400";
+    readonly Oswald: "Oswald:wght@300;400;500;600;700";
+    readonly Ubuntu: "Ubuntu:ital,wght@0,300;0,400;0,500;0,700;1,400";
 };
 declare const SPEC_SCHEMES: {
     readonly default: {
@@ -1464,7 +1473,6 @@ declare const SPEC_FIELD_CLASS_BASELINE: {
 declare const SPEC_LEGACY_ALIASES: {
     readonly "radius-control": "var(--iox-button-radius)";
     readonly "radius-surface": "var(--iox-card-radius)";
-    readonly "space-control": "var(--iox-button-pad)";
     readonly "space-stack": "var(--iox-space-gap)";
 };
 declare const SPEC_FLAVOR_PACKS: readonly [{
@@ -8174,6 +8182,11 @@ declare function styleKeyToKebab(key: string): string;
  *   4. reduced transparency `@media (prefers-reduced-transparency: reduce)`
  *   5. dark — LAST     `@media (prefers-color-scheme: dark)`
  *
+ * MODE (design-system D6) is a compile choice, never a row change: `auto` is the visitor-following
+ * order above; `light` compiles the base from light values and emits no dark block; `dark` compiles
+ * the base from DARK values (schemes and placeholders resolved from them too) and emits no dark block —
+ * so a Midnight site is dark for a light-OS visitor.
+ *
  * ⚠️ The appended-last contract: the dark block REDEFINES custom properties, so every consumer
  * appends it AFTER all of its base rules — the engine pushes it after the page's css blocks, the
  * builder registry keeps it as its last token rule (responsive A3 lesson).
@@ -8192,6 +8205,16 @@ interface DesignTokenLike {
 interface TokenCssOptions {
     /** Selector that carries the variables instead of `:root` — a preview wrapper, a specimen. */
     scope?: string;
+    /** The studio's colour mode (`settings.design.mode`). Absent = `auto`. */
+    mode?: DesignMode;
+    /**
+     * Declare every SPEC token the rows lack as `initial` on the scope (the guaranteed-invalid value),
+     * so a `var()` inside the scope cannot inherit a same-named property from an ANCESTOR. The builder
+     * needs it: the admin's `:root` chrome tokens share names with org tokens (`accent`, `surface-2`…),
+     * and a missing org row would silently paint the canvas in admin chrome. With it, the canvas
+     * computes exactly what the live site computes for that row — unset.
+     */
+    isolate?: boolean;
 }
 interface TokenCssBlocks {
     /** Base, schemes and the two accessibility blocks — emitted BEFORE node rules. */
@@ -8241,8 +8264,9 @@ declare function compileTokenCss(tokens: ReadonlyArray<DesignTokenLike> | null |
  * Flavors v1 (flavors-and-theming-plan.md, F1–F2): a pack is its TOKENS plus the accent hue
  * opinion the brand derivation reads. The per-type `defaults` map and its resolvers are gone
  * (design-system plan §3e, DS2): a new element is born wearing an ELEMENT STYLE
- * (`element-styles.ts`), which references tokens and is flavor-independent. Swiss survives only
- * until DS4 migrates orgs to Crisp.
+ * (`element-styles.ts`), which references tokens and is flavor-independent. Swiss is retired (DS4
+ * migrates `flavorId: swiss` orgs to Crisp); its pack stays as the migration's BASELINE — what F1/F2
+ * wrote, so "untouched since seeding" stays a comparison (`design-apply.ts`).
  */
 interface FlavorTokenDef {
     name: string;
@@ -8268,9 +8292,9 @@ interface FlavorPack {
 /** A pack's own sanity: every token row names itself and carries a value. Returns errors. */
 declare function validateFlavorPack(pack: FlavorPack): string[];
 /**
- * Swiss — the F1 pack: four tokens (control/surface radius, control/stack spacing) and the hue
- * opinion F2's brand step reads. Kept until DS4 migrates `flavorId: swiss` orgs to Crisp; its four
- * rows are the spec's `legacyAliases`.
+ * Swiss — the retired F1 pack: four tokens (control/surface radius, control/stack spacing) and the
+ * hue opinion F2's brand step read. Three of its rows become the spec's `legacyAliases` on migration;
+ * `space-control` is a v2 token in every pack and takes Crisp's value.
  */
 declare const SWISS_FLAVOR: FlavorPack;
 
@@ -8379,23 +8403,14 @@ declare function ownedTraitStatus(target: ElementStyleTarget, id: string): Owned
 declare function switchElementStyle(target: ElementStyleTarget, fromId: string | null | undefined, toId: string, baseline?: Readonly<Record<string, unknown>>): SwitchElementStyleResult;
 /**
  * The element-style MARKER (design-system §3b-bis, spec `elementStyleMarker`). A node that wears an
- * element style renders `iox-es iox-es-<id>` in BOTH renderers; every piece of component CSS that
- * carries the system look is scoped to it, so a node saved before DS2 (no `elementStyle`) keeps its
- * exact pre-DS2 component CSS no matter which tokens the org holds. This is the ONLY thing a
- * renderer reads `elementStyle` for.
+ * element style renders `iox-es iox-es-<id>` in BOTH renderers, through the one node-class helper
+ * `nodeDesignClasses` (node-classes.ts); every piece of component CSS that carries the system look is
+ * scoped to it, so a node saved before DS2 (no `elementStyle`) keeps its exact pre-DS2 component CSS
+ * no matter which tokens the org holds.
  */
 declare const ELEMENT_STYLE_MARKER_CLASS = "iox-es";
 /** `iox-es-<id>` for a known style, else null — an unknown id never reaches a class attribute. */
 declare function elementStyleClass(id: string | null | undefined): string | null;
-/** The marker classes a node renders: `'iox-es iox-es-<id>'`, or `''` for a node with no (known) style. */
-declare function elementStyleClasses(node: {
-    elementStyle?: string | null;
-} | null | undefined): string;
-/** Make an element's marker match `elementStyle` — the live switch on the canvas, and the
- *  component path's one-time stamp. Removes a stale `iox-es-<old>`; touches no other class. */
-declare function syncElementStyleMarker(el: {
-    classList: DOMTokenList;
-} | null | undefined, elementStyle: string | null | undefined): void;
 /**
  * The spec's `headingLevelRule`: changing a Heading's level moves it to the new level's DEFAULT
  * style only when it still wears its old level's default (author changes kept, via
@@ -8404,6 +8419,91 @@ declare function syncElementStyleMarker(el: {
  */
 declare function applyHeadingLevelRule(target: ElementStyleTarget, oldLevel: string | null | undefined, newLevel: string | null | undefined, baseline?: Readonly<Record<string, unknown>>): SwitchElementStyleResult | null;
 
+/**
+ * The design-system classes a node renders, in BOTH renderers (builder canvas, engine component
+ * path, engine string path) — ONE helper, so the three can never disagree about which class a node
+ * carries:
+ *
+ * - the element-style MARKER `iox-es iox-es-<id>` (design-system §3b-bis) — component CSS carrying
+ *   the system look is scoped to it, so a node saved before DS2 keeps its pre-DS2 look;
+ * - the section colour scheme `iox-scheme-<id>` (§3c) for a non-default `colorScheme` — the class
+ *   `compileSchemeCss` re-declares tokens on, so everything inside re-resolves.
+ *
+ * Renderers read `elementStyle` and `colorScheme` for exactly this and nothing else.
+ */
+/** The section colour schemes — the contract's `schemes` keys. */
+declare enum ColorScheme {
+    Default = "default",
+    Subtle = "subtle",
+    Inverse = "inverse",
+    Accent = "accent"
+}
+/** The content trait (stored in `props`, not a style prop) that picks a node's scheme. */
+declare const COLOR_SCHEME_TRAIT = "colorScheme";
+/** The node types that offer a scheme (spec §3c: Section/Container; LinkedContainer is a Container that links). */
+declare const COLOR_SCHEME_TYPES: ReadonlyArray<string>;
+/** Every scheme in contract order, with the contract's label (Default · Subtle · Inverse · Brand). */
+declare const COLOR_SCHEMES: ReadonlyArray<{
+    readonly id: ColorScheme;
+    readonly label: string;
+}>;
+/** `iox-scheme-<id>` for a known NON-default scheme, else null — an unknown id never reaches a class attribute. */
+declare function colorSchemeClass(id: unknown): string | null;
+/** The node shapes this module reads: a serialized node (`props`) or a builder node (`traits[]`). */
+interface DesignClassSource {
+    elementStyle?: string | null;
+    props?: Readonly<Record<string, unknown>> | null;
+    traits?: ReadonlyArray<{
+        name?: string;
+        default?: unknown;
+    }> | null;
+}
+/** A node's `colorScheme`, from `props` (serialized) or its trait (builder). */
+declare function colorSchemeOf(node: DesignClassSource | null | undefined): string | null;
+/** True when the node wears a known element style — the marker is on it. */
+declare function hasElementStyleMarker(node: {
+    elementStyle?: string | null;
+} | null | undefined): boolean;
+/** The classes a node renders: `'iox-es iox-es-card iox-scheme-inverse'`, or `''` for none. */
+declare function nodeDesignClasses(node: DesignClassSource | null | undefined): string;
+/** Make an element's design classes match the node — the live switch on the canvas and the
+ *  component path's one-time stamp. Removes stale ones; touches no other class. */
+declare function syncNodeDesignClasses(el: {
+    classList: DOMTokenList;
+} | null | undefined, node: DesignClassSource | null | undefined): void;
+
+/**
+ * Empty images (design-system DS3). A MARKED Image (`.iox-es-media`) with no source renders a box in
+ * the `surface-2` token with its aspect ratio kept — on the canvas with an "Add image" label, on the
+ * live site with nothing in it. An UNMARKED empty Image renders exactly as before (no `src`).
+ *
+ * Why a placeholder `src` instead of a src-less `<img>`: Chromium paints a src-less image as a broken
+ * image (a frame, an icon and the alt text) and ignores `aspect-ratio` once alt text is present, and no
+ * pseudo-element paints on an `<img>`. A real image with no natural size of its own (an SVG with no
+ * width/height) is a proper replaced element: `aspect-ratio`/`object-fit` apply, the background shows
+ * through, and its default object size (300×150) is the SAME for the canvas label and the live blank,
+ * so both renderers lay the box out identically. The fill itself is shared CSS (`iox-design.css`)
+ * keyed on {@link EMPTY_IMAGE_ATTRIBUTE}.
+ */
+/** Set on a marked Image while it has no source — the hook the shared fill rule keys on. */
+declare const EMPTY_IMAGE_ATTRIBUTE = "data-iox-empty";
+/** The live site's blank: an SVG with no intrinsic size and nothing in it. */
+declare const EMPTY_IMAGE_SRC: string;
+/**
+ * The canvas blank: the same no-size SVG with `label` centred as a chip. The chip carries its own
+ * light ground, so it reads on every flavor's `surface-2`, light or dark; it is builder chrome, never
+ * site content. Width is estimated from the label length (an image cannot measure text).
+ */
+declare function emptyImageLabelSrc(label: string): string;
+/**
+ * The `src` a node's Image renders when its own source is empty: the canvas label (when `label` is
+ * given) or the live blank for a MARKED node; `null` — render exactly as before — for an unmarked
+ * node or one that has a source.
+ */
+declare function emptyImageSrc(node: {
+    elementStyle?: string | null;
+} | null | undefined, src: unknown, label?: string | null): string | null;
+
 /**
  * BRAND DERIVATION (flavors plan §6, F2): one colour in, an asserted accessible ramp out.
  *
@@ -8529,17 +8629,29 @@ declare function revertAvailable(appliedAt: number | null | undefined, now: numb
  * to touch — a revert undoes the FLAVOR, not the author's week.
  */
 declare function planFlavorRevert(current: ReadonlyArray<StoredDesignTokenRow>, snapshot: FlavorRevertSnapshot['tokens']): FlavorRevertPlan;
+/** What a previous seed wrote for one row — the "untouched" comparison base. */
+interface SeedExpectation {
+    value: string;
+    dark?: string;
+}
+/**
+ * What the PREVIOUS seed wrote, per row: a map by name, or a function of the stored row (a baseline
+ * that depends on WHICH seed stamped the row — the Swiss → Crisp migration's case).
+ */
+type SeedBaseline = ReadonlyMap<string, SeedExpectation> | ((row: StoredDesignTokenRow) => SeedExpectation | undefined);
 /**
  * The seeding MERGE: desired tokens vs existing rows, deciding create / update / keep. The §10 C2
  * rule — "an upgrade only rewrites untouched rows" — is a comparison against what the PREVIOUS
- * seed wrote (`oldExpected`): a seeded row whose value still equals it is the machine's and may be
- * rewritten; any drift means the author took it over, and their hand wins. A row without a
- * `flavor:` stamp is never touched at all. `group`/`tier` ride every write.
+ * seed wrote (`baseline`): a seeded row whose value still equals it is the machine's and may be
+ * rewritten; any drift means the author took it over, and their hand wins. A row the design did not
+ * write is never touched: no `flavor:` stamp, unless it is a `user` row (a font the author CHOSE in
+ * the design) whose value is exactly what the previous design wrote — that row is the design's own
+ * choice, so a new choice may replace it. `group`/`tier` ride every write; a desired row's own
+ * `source` (a chosen font's `user`) wins over the pack stamp.
  */
-declare function planFlavorSeed(desired: ReadonlyArray<FlavorTokenDef>, existing: ReadonlyArray<StoredDesignTokenRow>, stamp: string, oldExpected: Map<string, {
-    value: string;
-    dark?: string;
-}> | null): FlavorSeedPlan;
+declare function planFlavorSeed(desired: ReadonlyArray<FlavorTokenDef & {
+    source?: string;
+}>, existing: ReadonlyArray<StoredDesignTokenRow>, stamp: string, baseline: SeedBaseline | null): FlavorSeedPlan;
 
 interface LinearSpring {
     easing: string;
@@ -8576,11 +8688,27 @@ declare function cssString(value: string): string;
 declare function buildFontFaceCss(descriptors: ReadonlyArray<FontDescriptor> | null | undefined): string;
 /** The family names in a CSS `font-family` stack, unquoted, in order. */
 declare function parseFontFamilies(stack: string): string[];
+/** Where Google serves the stylesheets, and the origin the font FILES come from (preconnect). */
+declare const GOOGLE_FONTS_CSS_ORIGIN = "https://fonts.googleapis.com";
+declare const GOOGLE_FONTS_FILE_ORIGIN = "https://fonts.gstatic.com";
+/** The ONE stylesheet URL for a catalog id — both renderers link exactly this (one per family, T7). */
+declare function googleFontHref(id: string): string;
+/** The catalog id of a family name (case-insensitive), or null — a system or uploaded face has none. */
+declare function catalogFontId(family: string | null | undefined): string | null;
+interface FontsForTokensOptions {
+    /**
+     * The CSS that will actually render (node rules, element styles). `font-mono` is loaded only when
+     * something READS it — here or in another token's value — because no element style does: an org
+     * would otherwise download a monospace face for a site with no code on it.
+     */
+    usedCss?: string;
+}
 /**
- * The Google css2 ids to load for a token set: every catalog family named by a font role token,
- * one id per family (T7 — one `<link>` per family, so one bad id cannot sink the others).
+ * The Google css2 ids to load for a token set: every catalog family named by the display / body /
+ * label roles, plus mono when referenced (above). One id per family (T7 — one `<link>` per family, so
+ * one bad id cannot sink the others), in role order.
  */
-declare function fontsForTokens(tokens: ReadonlyArray<DesignTokenLike> | null | undefined): string[];
+declare function fontsForTokens(tokens: ReadonlyArray<DesignTokenLike> | null | undefined, opts?: FontsForTokensOptions): string[];
 
 /**
  * Which `--iox-<name>` a piece of COMPONENT CSS may reference (design-system §3b-bis: "component CSS
@@ -8595,6 +8723,111 @@ declare function specTokenNames(): ReadonlySet<string>;
 declare function tokenReferences(css: string): string[];
 /** The referenced names that are neither spec tokens nor in `alsoAllowed`. */
 declare function unknownTokenReferences(css: string, alsoAllowed?: Iterable<string>): string[];
+/**
+ * Tokens read by a LEGACY rule — any rule whose selector is scoped `:not(.iox-es)` (the pre-DS2 look
+ * of a node that wears no element style, design-system §3b-bis). Such a rule must read NO token at
+ * all: a token it reads repaints a pre-DS2 page the moment the org's rows are seeded or a flavor is
+ * applied (D5). Returns `selector → names` for each offending rule; comments are ignored.
+ */
+declare function legacyRuleTokenReferences(css: string): Array<{
+    selector: string;
+    tokens: string[];
+}>;
+
+/**
+ * The `settings.design` row (design-system plan §3f), read and written by ONE pair of functions so
+ * the builder, the server's public page read (the engine's mode) and the site build agree on what a
+ * stored row MEANS. The row is the settings collection's generic `config: [{ key, value }]`; values
+ * are strings there (Boolean "true"/"false", Object as JSON), but a reader also accepts the typed
+ * value a client control may have sent.
+ */
+/** The look a studio wears until it picks one (DS2's interim seed, and DS6's first-run selection). */
+declare const DEFAULT_FLAVOR_ID = "crisp";
+/** One `config` entry of a settings row. */
+interface DesignConfigEntry {
+    key: string;
+    value: unknown;
+}
+declare enum DesignConfigKey {
+    FlavorId = "flavorId",
+    FlavorVersion = "flavorVersion",
+    BrandSeed = "brandSeed",
+    PairId = "pairId",
+    Shape = "shape",
+    Density = "density",
+    Motion = "motion",
+    PillButtons = "pillButtons",
+    Mode = "mode",
+    Fonts = "fonts",
+    Revert = "revert"
+}
+/** A stored design, resolved: `choices` is ALWAYS complete and valid (pack defaults fill the gaps). */
+interface StoredDesign {
+    choices: DesignChoices;
+    /** The flavor id exactly as stored — `swiss` until the DS4 migration rewrites it; null when no row. */
+    storedFlavorId: string | null;
+    /** The seed exactly as stored (F2 orgs carry their brand colour here); null when absent. */
+    storedSeed: string | null;
+    flavorVersion: string | null;
+    revert: FlavorRevertSnapshot | null;
+    /** False when the org has never stored a design — DS6's first run. */
+    hasRow: boolean;
+}
+/** The pack for an id; a retired id (Swiss) resolves to the pack that `replaces` it. */
+declare function flavorPackById(id: string | null | undefined): FlavorPackV2 | undefined;
+/** True when `id` names a retired flavor that a v2 pack replaces (Swiss → Crisp). */
+declare function isRetiredFlavorId(id: string | null | undefined): boolean;
+/**
+ * A partial set of choices completed against its pack: every missing or invalid value falls back to
+ * the pack's own default (an unknown pair → the pack's first, a bad seed → the pack's seed).
+ */
+declare function resolveDesignChoices(partial: Partial<DesignChoices> | null | undefined): DesignChoices;
+/** The pack's own defaults for `flavorId` — what picking a card means before anything is tuned. */
+declare function packDesignChoices(flavorId: string): DesignChoices;
+/** A stored `settings.design` config → the resolved design. No row (or no config) → Crisp's defaults. */
+declare function readDesignConfig(config: ReadonlyArray<DesignConfigEntry> | null | undefined, hasRow?: boolean): StoredDesign;
+/** The colour mode a stored config compiles in — what the public page read hands the engine. */
+declare function designModeOf(config: ReadonlyArray<DesignConfigEntry> | null | undefined): DesignMode;
+/** Resolved choices (+ the revert snapshot) → the config array a settings row stores. */
+declare function designConfigEntries(choices: DesignChoices, flavorVersion: string | number, revert?: FlavorRevertSnapshot | null): DesignConfigEntry[];
+/** Two choice sets describe the same look (fonts compared by role). */
+declare function sameDesignChoices(a: DesignChoices, b: DesignChoices): boolean;
+
+/** Every row a design writes — `buildFlavorTokens` for its pack. Empty for an unknown pack. */
+declare function designTokenRows(choices: DesignChoices): DesignTokenRow[];
+/**
+ * What the PREVIOUS design wrote, as a baseline keyed by the row's own stamp: a row Swiss stamped is
+ * judged against what Swiss wrote, every other row against `buildFlavorTokens` of the stored choices
+ * (for an org with no design row, Crisp's defaults — exactly what DS2's interim seed wrote). In a
+ * Swiss org the only v2 rows are that interim seed's, so they are judged against Crisp's DEFAULTS,
+ * never against the brand-seeded Crisp the migration is about to write.
+ */
+declare function designBaseline(previous: StoredDesign): SeedBaseline;
+/** Apply `next` over the org's rows, judged against `previous` — the plan FlavorApplyService runs. */
+declare function planDesignApply(existing: ReadonlyArray<StoredDesignTokenRow>, previous: StoredDesign, next: DesignChoices): FlavorSeedPlan;
+/** The rows a design is missing by name — the builder-load top-up (never touches an existing row). */
+declare function missingDesignRows(existing: ReadonlyArray<{
+    name: string;
+}>, choices: DesignChoices): DesignTokenRow[];
+interface SwissMigration {
+    /** The design the org now wears: Crisp, carrying the stored brand seed when it is a colour. */
+    choices: DesignChoices;
+    /** The token merge, the four legacy alias rewrites included. */
+    plan: FlavorSeedPlan;
+}
+/**
+ * Swiss → Crisp (spec `legacyAliases`; D1). Needed when the design row says a retired flavor, or when
+ * there is no design row but the org holds Swiss-stamped alias rows (F1 seeded those before the row
+ * existed). Idempotent: once the row says Crisp nothing is needed, and re-running the plan writes
+ * nothing.
+ *
+ * - The look: `planDesignApply` from Swiss to Crisp — Swiss-stamped rows untouched since Swiss seeded
+ *   them (incl. F2's `surface` / `line` / `accent`) become Crisp's; edited ones are kept.
+ * - The aliases: `radius-control` / `radius-surface` / `space-control` / `space-stack` are rewritten to
+ *   their alias reference ONLY while still machine-owned and untouched, so a node saved since F1 that
+ *   reads `var(--iox-radius-control)` keeps resolving — now to Crisp's button radius.
+ */
+declare function planSwissMigration(existing: ReadonlyArray<StoredDesignTokenRow>, stored: StoredDesign): SwissMigration | null;
 
-export { ACCENT_TOKEN_NAMES, BUTTON_VARIANT_TO_STYLE, DESIGN_TOKEN_GROUPS, DESIGN_TOKEN_TIERS, DESIGN_TOKEN_TYPES, ELEMENT_STYLES, ELEMENT_STYLE_MARKER_CLASS, ELEMENT_STYLE_STATES, ElementStyleState, FLAVOR_SPEC_VERSION, FONT_CATALOG, FONT_FAMILY_TOKENS, OwnedTraitLink, PALETTE_PRESETS, REDUCED_MOTION_OVERRIDES, REDUCED_TRANSPARENCY_OVERRIDES, REVERT_WINDOW_MS, SPEC_A11Y, SPEC_AXES, SPEC_BUTTON_VARIANT_TO_STYLE, SPEC_CONTRAST, SPEC_DEFAULT_ELEMENT_STYLE, SPEC_ELEMENT_STYLES, SPEC_FIELD_CLASS_BASELINE, SPEC_FLAVORS, SPEC_FLAVOR_PACKS, SPEC_FONTS, SPEC_FONT_ROLES, SPEC_LEGACY_ALIASES, SPEC_PALETTE_PRESETS, SPEC_SCHEMES, SPEC_SPRINGS, SPEC_TIERS, SPEC_TIER_IDS, SPEC_TOKEN_TYPES, SWISS_FLAVOR, USER_TOKEN_SOURCE, WCAG_AA_TEXT, apcaLc, applyElementStyle, applyHeadingLevelRule, buildFlavorTokens, buildFontFaceCss, compileSchemeCss, compileTokenCss, compileTokenCssBlocks, cssString, defaultDesignChoices, defaultElementStyleFor, deriveAccentTokens, deriveBrandTokens, elementStyleById, elementStyleClass, elementStyleClasses, elementStylesFor, flavorSourceStamp, fontsForTokens, isDesignTokenGroup, isDesignTokenTier, isDesignTokenType, oklabToRgb, ownedTraitStatus, parseFontFamilies, parseHexColor, planFlavorRevert, planFlavorSeed, relativeLuminance, resolveTokenReferences, resolveTokenValues, revertAvailable, rgbToOklab, specTokenNames, springToLinear, styleKeyToKebab, switchElementStyle, syncElementStyleMarker, toHexColor, tokenReferences, tokensToDarkVarMap, tokensToVarMap, unknownTokenReferences, userFontStack, validateFlavorPack, wcagContrastRatio };
-export type { AccentBackgrounds, AccentTokenName, ApplyElementStyleResult, DensityId, DesignChoices, DesignMode, DesignTokenGroup, DesignTokenLike, DesignTokenRow, DesignTokenTier, DesignTokenType, ElementStyle, ElementStyleTarget, ElementStyleTraitLike, FlavorPack, FlavorPackV2, FlavorRevertPlan, FlavorRevertSnapshot, FlavorSeedPlan, FlavorSpecToken, FlavorTokenDef, FontDescriptor, FontFormat, FontPair, FontRoleToken, FontStyle, LinearSpring, MotionId, OkLab, OwnedTrait, OwnedTraitStatus, PalettePreset, ResolvedMode, Rgb, SchemeId, ShapeId, StoredDesignTokenRow, SwitchElementStyleResult, TokenCssBlocks, TokenCssOptions };
+export { ACCENT_TOKEN_NAMES, BUTTON_VARIANT_TO_STYLE, COLOR_SCHEMES, COLOR_SCHEME_TRAIT, COLOR_SCHEME_TYPES, ColorScheme, DEFAULT_FLAVOR_ID, DESIGN_TOKEN_GROUPS, DESIGN_TOKEN_TIERS, DESIGN_TOKEN_TYPES, DesignConfigKey, ELEMENT_STYLES, ELEMENT_STYLE_MARKER_CLASS, ELEMENT_STYLE_STATES, EMPTY_IMAGE_ATTRIBUTE, EMPTY_IMAGE_SRC, ElementStyleState, FLAVOR_SPEC_VERSION, FONT_CATALOG, FONT_FAMILY_TOKENS, GOOGLE_FONTS_CSS_ORIGIN, GOOGLE_FONTS_FILE_ORIGIN, OwnedTraitLink, PALETTE_PRESETS, REDUCED_MOTION_OVERRIDES, REDUCED_TRANSPARENCY_OVERRIDES, REVERT_WINDOW_MS, SPEC_A11Y, SPEC_AXES, SPEC_BUTTON_VARIANT_TO_STYLE, SPEC_CONTRAST, SPEC_DEFAULT_ELEMENT_STYLE, SPEC_ELEMENT_STYLES, SPEC_FIELD_CLASS_BASELINE, SPEC_FLAVORS, SPEC_FLAVOR_PACKS, SPEC_FONTS, SPEC_FONT_ROLES, SPEC_LEGACY_ALIASES, SPEC_PALETTE_PRESETS, SPEC_SCHEMES, SPEC_SPRINGS, SPEC_TIERS, SPEC_TIER_IDS, SPEC_TOKEN_TYPES, SWISS_FLAVOR, USER_TOKEN_SOURCE, WCAG_AA_TEXT, apcaLc, applyElementStyle, applyHeadingLevelRule, buildFlavorTokens, buildFontFaceCss, catalogFontId, colorSchemeClass, colorSchemeOf, compileSchemeCss, compileTokenCss, compileTokenCssBlocks, cssString, defaultDesignChoices, defaultElementStyleFor, deriveAccentTokens, deriveBrandTokens, designBaseline, designConfigEntries, designModeOf, designTokenRows, elementStyleById, elementStyleClass, elementStylesFor, emptyImageLabelSrc, emptyImageSrc, flavorPackById, flavorSourceStamp, fontsForTokens, googleFontHref, hasElementStyleMarker, isDesignTokenGroup, isDesignTokenTier, isDesignTokenType, isRetiredFlavorId, legacyRuleTokenReferences, missingDesignRows, nodeDesignClasses, oklabToRgb, ownedTraitStatus, packDesignChoices, parseFontFamilies, parseHexColor, planDesignApply, planFlavorRevert, planFlavorSeed, planSwissMigration, readDesignConfig, relativeLuminance, resolveDesignChoices, resolveTokenReferences, resolveTokenValues, revertAvailable, rgbToOklab, sameDesignChoices, specTokenNames, springToLinear, styleKeyToKebab, switchElementStyle, syncNodeDesignClasses, toHexColor, tokenReferences, tokensToDarkVarMap, tokensToVarMap, unknownTokenReferences, userFontStack, validateFlavorPack, wcagContrastRatio };
+export type { AccentBackgrounds, AccentTokenName, ApplyElementStyleResult, DensityId, DesignChoices, DesignClassSource, DesignConfigEntry, DesignMode, DesignTokenGroup, DesignTokenLike, DesignTokenRow, DesignTokenTier, DesignTokenType, ElementStyle, ElementStyleTarget, ElementStyleTraitLike, FlavorPack, FlavorPackV2, FlavorRevertPlan, FlavorRevertSnapshot, FlavorSeedPlan, FlavorSpecToken, FlavorTokenDef, FontDescriptor, FontFormat, FontPair, FontRoleToken, FontStyle, FontsForTokensOptions, LinearSpring, MotionId, OkLab, OwnedTrait, OwnedTraitStatus, PalettePreset, ResolvedMode, Rgb, SchemeId, SeedBaseline, SeedExpectation, ShapeId, StoredDesign, StoredDesignTokenRow, SwissMigration, SwitchElementStyleResult, TokenCssBlocks, TokenCssOptions };