export type ColorScheme = "light" | "dark";
/** Semantic color tokens. The named surface/intent colors components paint with. */
export interface ColorTokens {
    /** Authored brand artwork stops and the featured card's offset stack. */
    "featured-start"?: string;
    "featured-middle"?: string;
    "featured-end"?: string;
    "featured-stack"?: string;
    "promo-start"?: string;
    "promo-middle"?: string;
    "promo-end"?: string;
    /** Optional informational text ink supplied by a brand. */
    info?: string;
    background: string;
    /** The sunken well beneath the page: a field's fill, a code block, a preview stage. Omit to use `background`. */
    "surface-sunken"?: string;
    /** The raised step above `secondary`: a hovered secondary fill, an off switch track. Omit to use `secondary`. */
    "surface-raised"?: string;
    /** The tertiary ink: captions, placeholders, eyebrows, mono metadata. Omit to use `muted-foreground`. */
    "subtle-foreground"?: string;
    foreground: string;
    card: string;
    "card-foreground": string;
    popover: string;
    "popover-foreground": string;
    primary: string;
    /** Brand text on neutral/tinted surfaces. Omit in legacy maps to use primary. */
    "primary-text"?: string;
    "primary-foreground": string;
    /**
     * The CALL-TO-ACTION fill: the primary Button and the split button's action. Kept
     * apart from `primary`, which paints what is selected, checked, current, linked or
     * focused (the v4 hand-off paints both in its accent). Omit in legacy maps to paint actions with `primary`; a `tokens` override
     * that sets only `primary` repaints the actions too.
     */
    action?: string;
    /** The label and icon ink on an `action` fill. Omit to use `primary-foreground`. */
    "action-foreground"?: string;
    secondary: string;
    "secondary-foreground": string;
    muted: string;
    "muted-foreground": string;
    accent: string;
    "accent-foreground": string;
    destructive: string;
    /** Error/action text on neutral surfaces. Omit in legacy maps to use destructive. */
    "destructive-text"?: string;
    "destructive-foreground": string;
    success: string;
    /** Success text on neutral surfaces and its own wash. Omit in legacy maps to use success. */
    "success-text"?: string;
    "success-foreground": string;
    warning: string;
    /** Warning text on neutral surfaces and its own wash. Omit in legacy maps to use warning. */
    "warning-text"?: string;
    "warning-foreground": string;
    border: string;
    input: string;
    /**
     * The RESTING border of a text field on the web and iOS skins (Input, Textarea,
     * Select, Autocomplete, InputOTP, Stepper, PhoneInput, the Command trigger), and
     * the hand-off's strong hairline (--ln2), also used by `input`. The roles remain
     * independently overridable. Focus and error paint `ring` and `destructive`.
     * Omit in legacy maps to rest on `input`.
     */
    "field-border"?: string;
    ring: string;
    /** The accent's glow: the halo under a raised primary, a slider fill, an active tab line. Translucent. Omit to glow with `ring`. */
    glow?: string;
    /** The inset top highlight a lit surface carries (`inset 0 1px 0`). Translucent. Omit for none. */
    highlight?: string;
    /**
     * The soft washes (the hand-off's `*Soft`): a status or selection color at low alpha,
     * the fill behind a toned badge, an alert band or a tonal selection. Translucent
     * (`rgba`) by contract: composite one on the surface it sits on before measuring it.
     * Omit in legacy maps; a skin then washes the role's own color itself.
     */
    "primary-soft"?: string;
    "action-soft"?: string;
    "info-soft"?: string;
    "success-soft"?: string;
    "warning-soft"?: string;
    "destructive-soft"?: string;
    /** A text field's own fill (the hand-off's translucent white well). Translucent. Omit to fill with `card`. */
    "field-fill"?: string;
    /**
     * The hover wash (the hand-off's `hover`): the brand violet at a low alpha beneath a
     * hovered row or quiet control. Translucent, so it reads on any surface and over glass;
     * `accent` is this wash composited on `card`. Omit to wash with `accent`.
     */
    hover?: string;
    /** The modal backdrop (the hand-off's tinted dim). Translucent. Omit to dim with black. */
    scrim?: string;
    /** The small elevation's drop colour (a card, a tile). Translucent. Omit to shade with the ink. */
    shade?: string;
    /** The raised elevation's drop colour (a menu, a popover, a hovered card). Translucent. Omit to use `shade`. */
    "shade-md"?: string;
    /** The overlay elevation's drop colour (a dialog, a sheet, the floating chrome). Translucent. Omit to use `shade-md`. */
    "shade-lg"?: string;
    /** The hairline ring the light scheme's elevations carry. Translucent. Omit for none. */
    "shade-ring"?: string;
    /**
     * The lit top edge the dark scheme's elevations carry (an inset 1px line in `highlight`).
     * Transparent in the light scheme. Omit for none.
     */
    "shade-inset"?: string;
    /**
     * The inverse surface (the hand-off's dark toast pill, which the Android snackbar paints in both
     * schemes) and the ink on it. Omit both in legacy maps to invert the scheme: `foreground`
     * as the pill and `background` as its ink. Override the three inverse roles together:
     * the palette's ink and action name the hand-off's matching colors; an `inverse` alone keeps
     * those colors.
     */
    inverse?: string;
    "inverse-foreground"?: string;
    /**
     * The brand on the inverse surface (Material 3's inverse-primary): the action a
     * snackbar carries on the `inverse` pill, the palette's own brand hue lightened until
     * it reads at 4.5:1 on the pill, solid and under glass. Omit in legacy maps to use the
     * brand text of the palette whose surfaces match the pill's lightness (the dark
     * palette's on a dark pill, the light palette's on a light one). A `tokens` override
     * that rebrands `primary` leaves it alone: name it too.
     */
    "inverse-primary"?: string;
    "chart-1": string;
    "chart-2": string;
    "chart-3": string;
    "chart-4": string;
    "chart-5": string;
    "chart-6": string;
    "chart-7": string;
    "chart-8": string;
}
/**
 * The glass material's own tokens, per scheme, one tint per density layer.
 * These densities do not choose static versus liquid material or custom motion.
 * The role-based contract uses intentional static content panes and functional
 * liquid surfaces, with unpainted layout, foreground content and data ink.
 * Readability must be verified on actual composed backgrounds, not inferred from
 * a token or a passing contrast check against one backdrop.
 *
 *   glass-tint          the FUNCTIONAL layer: bars, sidebars, tab bars, sheets,
 *                       drawers, popovers, dialogs, the command palette. The
 *                       thinnest tint; the material does most of the read.
 *   glass-tint-content  CONTENT panes: cards, tables, lists, tiles, feeds, the
 *                       calendar, chart frames, the docs stages. Dense enough
 *                       that `foreground` text clears 4.5:1 over the page and
 *                       over every bed of the frosted frame (frameBeds; test/glass-tint.test.tsx).
 *   glass-tint-control  CONTROLS: fields, buttons, segmented controls, chips,
 *                       badges, pills. A brighter "puck" than the pane it sits
 *                       on, in both schemes.
 *   glass-tint-dense    the surfaces the user READS rows or a verdict from: option
 *                       lists (dropdown, select, autocomplete, row menus), alert
 *                       dialogs, toasts. The densest tint, so the page's own rows
 *                       and rules never read between the menu's.
 *
 * The material carries its OWN fill; glass mode swaps NO semantic color token
 * (`card` and `popover` stay opaque in the token set, and a surface that opts out of
 * the material keeps its opaque fill). Every surface takes its tint UNDER the real
 * material selected by the shared renderer for the role and available capability.
 * Native Liquid Glass, the native frost and the web's plain frost are distinct material paths.
 * A tint alone is neither proof of real blur nor a complete solid fallback.
 * Missing or unsafe material capability requires the original opaque fill,
 * foreground, boundary and elevation; layout and semantic state must survive.
 *
 * Keys are the CSS custom-property names verbatim (`glass-tint` is `--glass-tint` in
 * styles/tokens/colors.css). The CSS hand-off carries the WEB frost's tints, Dark
 * Factory's (src/style/glass-surface/web-frost.ts), and scripts/validate-tokens.ts
 * holds the two together. `glassByScheme` below is the NATIVE set: the Android blur reads
 * it, and iOS's Liquid Glass and frost read it but for a sheerer dark control puck
 * (src/style/glass-surface/ios-tints.ts).
 * Values are rgba so they compose over whatever sits behind the surface.
 */
export interface GlassTokens {
    /** The functional layer's under-fill (bars, sheets, popovers, dialogs). */
    "glass-tint": string;
    /** The content pane's under-fill (cards, tables, lists, tiles, stages). */
    "glass-tint-content": string;
    /** The control puck's under-fill (fields, buttons, chips, badges, pills). */
    "glass-tint-control": string;
    /** The densest under-fill (option lists, alert dialogs, toasts). */
    "glass-tint-dense": string;
}
/**
 * The light scheme's native glass under-fills, one per material layer (functional,
 * content, control, dense), as glassByScheme carries them.
 */
export declare const lightGlass: GlassTokens;
/**
 * The dark scheme's native glass under-fills, one per material layer (functional, content,
 * control, dense), as glassByScheme carries them.
 */
export declare const darkGlass: GlassTokens;
/**
 * The native glass tints per scheme: the Android blur's, and iOS's Liquid Glass and frost
 * but for its dark control puck, which is sheerer there (white 0.05). The web's are Dark
 * Factory's frost tints; read the active platform's through `useTheme().glass`.
 */
export declare const glassByScheme: Record<ColorScheme, GlassTokens>;
/**
 * The accent palettes the kit ships, each one hue for the whole accent: violet (285, the
 * default), cyan (205), mint (165), rose (20) and amber (75). A palette applies in both
 * schemes. `<ThemeProvider cyan>` selects one; the CSS hand-off reads `data-palette`.
 */
export type Palette = "violet" | "cyan" | "mint" | "rose" | "amber";
/** Every palette, the default first. */
export declare const PALETTES: readonly Palette[];
/** The oklch hue each palette paints its accent at. */
export declare const paletteHue: Record<Palette, number>;
/**
 * The accent's oklch lightness and chroma per scheme, and its text and soft alphas.
 * Internal: tools/v4/derive-css.ts writes the CSS hand-off's oklch forms from it; the
 * package does not re-export it.
 */
export declare const ACCENT: {
    readonly dark: {
        readonly fill: readonly [0.74, 0.17];
        readonly text: readonly [0.8, 0.14];
        readonly ink: "#0a0a0f";
        readonly soft: 0.16;
        readonly glow: 0.5;
        readonly ring: 0.35;
    };
    readonly light: {
        readonly fill: readonly [0.5, 0.22];
        readonly text: readonly [0.47, 0.2];
        readonly ink: "#ffffff";
        readonly soft: 0.1;
        readonly glow: 0.4;
        readonly ring: 0.28;
    };
};
/**
 * The hand-off's fixed series 2 to 8 (series 1 is the accent), per scheme, as oklch.
 * Internal, read by tools/v4/derive-css.ts like ACCENT.
 */
export declare const SERIES: Record<ColorScheme, readonly (readonly [number, number, number])[]>;
/**
 * The scheme's neutrals, status colours, glass and shades: everything the hue does not move.
 * Internal, read by tools/v4/derive-inks.ts, which mirrors the hand-off’s text aliases.
 */
export declare const NEUTRALS: Record<ColorScheme, Omit<ColorTokens, AccentRole | ChartRole | InkRole>>;
type AccentRole = "primary" | "primary-text" | "primary-foreground" | "primary-soft" | "action" | "action-foreground" | "action-soft" | "info" | "info-soft" | "ring" | "glow" | "inverse-primary" | "featured-start" | "featured-middle" | "featured-end" | "featured-stack" | "promo-start" | "promo-middle" | "promo-end";
type ChartRole = "chart-1" | "chart-2" | "chart-3" | "chart-4" | "chart-5" | "chart-6" | "chart-7" | "chart-8";
export type InkRole = "destructive-text" | "success-text" | "warning-text";
/**
 * The semantic color tokens a palette paints in a scheme: the scheme's neutrals with the
 * palette's accent. A frozen value per pair, computed once.
 */
export declare function colorsFor(palette: Palette, scheme: ColorScheme): ColorTokens;
/**
 * The light scheme's semantic color tokens in the default violet palette. A frozen
 * constant: read the live set from `useTheme().tokens`.
 */
export declare const lightColors: ColorTokens;
/**
 * The dark scheme's semantic color tokens in the default violet palette. A frozen
 * constant: read the live set from `useTheme().tokens`.
 */
export declare const darkColors: ColorTokens;
/** The violet palette's semantic color tokens by scheme: lightColors and darkColors. */
export declare const colorsByScheme: Record<ColorScheme, ColorTokens>;
/**
 * The surfaces a glass pane can sit over in a scheme (the page, the sunken well and the
 * card), the beds a translucent fill carrying ink is solved against. The v4 page is flat,
 * so the beds are the scheme's own surfaces, whatever the palette.
 */
export declare function frameBedsFor(_palette: Palette, scheme: ColorScheme): readonly string[];
/** Fixed, scheme-independent base colors. */
export declare const baseColors: Record<string, string>;
/**
 * Tailwind red-500, single-sourced for Button's attention glow. An atom that reads a
 * hue through `palette[...]` retains the whole record (~1.5KB gzip) in every bundle
 * that carries it; this named constant tree-shakes to the one value.
 */
export declare const PALETTE_RED_500 = "#ef4444";
/**
 * The standard Tailwind v3 color-hue palette, scheme-independent. Color-coded
 * components that need hues beyond the semantic tokens read from here. Keyed
 * "<hue>-<step>" (e.g. "red-500"), values are the canonical Tailwind v3 hexes,
 * lowercase.
 */
export declare const palette: Record<string, string>;
/** Spacing scale in px (Tailwind rem * 16). Keys are the Tailwind step names. */
export declare const spacing: Record<string, number>;
/** Border radius scale in px. */
export declare const radius: Record<string, number>;
/** The platforms a skin file is written for. */
export type PlatformKey = "web" | "ios" | "android";
/**
 * The corner radii a platform's skins share, by what the corner belongs to. Skins
 * read these instead of spelling a number, so a shape decision is made once per
 * platform: `control` is a rectangular control on the web (an icon button, a menu row, a
 * nav highlight; a capsule control reads `pill`) and every iOS and Android control;
 * `field` a text field, select, or autocomplete box; `card` a content surface;
 * `dialog` a dialog or alert dialog; `menu` a menu, popover, or select list;
 * `sheet` a sheet, drawer, or app shell; `checkbox` the box of a checkbox; `pill`
 * a chip, badge, or capsule; `tile` an icon tile, a swatch, or an alert banner.
 * The roles only one platform or only the kit draws (a Material 3 chip, the iOS action
 * sheet, a keycap) are the rest of each platform's row, the kit-internal `platformShape`
 * (src/style/platform-shape.ts). tools/tokens/shape-roles.ts lists the skins that draw
 * each role per platform and the roles each component plays, and
 * test/design-rules-shape.test.ts holds every corner in the kit to the row of the platform
 * its skin draws: a role its component plays, the pill (9999), square (0), or concentric
 * with its container. The web row is mirrored as `--radius-*` in styles/tokens/radius.css.
 */
export interface ShapeTokens {
    control: number;
    field: number;
    card: number;
    dialog: number;
    menu: number;
    sheet: number;
    checkbox: number;
    pill: number;
    /** A tile: an icon tile, a swatch, an alert banner; tighter than a content card. */
    tile: number;
}
/**
 * The corner radius each platform's skins give a role (a control, a field, a card, a
 * dialog, a menu, a sheet, a checkbox, a pill, a tile), mirrored as `--radius-*` in the
 * CSS hand-off.
 */
export declare const shape: Record<PlatformKey, ShapeTokens>;
/**
 * Font size and matching line height, in px: a ladder from 12/16 (`xs`) up to 64/70
 * (`7xl`), mirrored in styles/tokens/typography.css `--text-*` / `--leading-*`. No kit
 * component reads it.
 */
export declare const fontSize: Record<string, {
    fontSize: number;
    lineHeight: number;
}>;
/** Font weights (RN expects string values). */
export declare const fontWeight: Record<string, string>;
/** Letter spacing (tracking) in px. */
export declare const letterSpacing: Record<string, number>;
/** Line height (leading) in px. Relative leadings are approximated as absolute. */
export declare const lineHeight: Record<string, number>;
/** The breakpoint keys, in ascending pixel order. */
export type BreakpointKey = "sm" | "md" | "lg" | "xl" | "2xl";
/** Desktop-first breakpoints in px: a variant applies at this width and below. */
export declare const breakpoints: Record<BreakpointKey, number>;
/** The width-scale steps, narrowest first. */
export type WidthKey = "xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl" | "wide" | "wider" | "widest" | "page";
/**
 * The one width scale every bounds-providing container draws from: Container's
 * measure axis, the Dialog and AlertDialog panels, the floating overlays, and any
 * call site that used to pin a `maxWidth` by hand. The values are Tailwind's
 * `max-w-xs` .. `max-w-7xl` steps copied verbatim (no dependency on Tailwind;
 * the numbers only), 64px apart from xs to xxl and then doubling strides, plus
 * two tile steps below xs (`max-w-48` and `max-w-64`, the small KPI card and the
 * chart tile), so the kit and the design mirror name widths instead of inventing
 * them. A component never carries one of these as a width of its own: it is FILL
 * or HUG (see `sizing.ts`), and the step is a cap, picked by the parent layout
 * container or named on the component through its measure axis (`MeasureProps`).
 * Declared narrowest first: `stepOf` reads this order as its precedence.
 */
export declare const widths: Record<WidthKey, number>;
export {};
//# sourceMappingURL=tokens.d.ts.map