design-token-library 0.3.0 → 0.4.0

package/dist/lib/public.d.ts

@@ -1,1405 +0,0 @@
-/**
- * Thrown when reading a token whose value refers back to itself through
- * one or more refs or computed values.
- *
- * @public
- */
-export declare class CircularReferenceError extends Error {
-    readonly name = "CircularReferenceError";
-    /**
-     * The names of the tokens in the cycle, starting and ending with the
-     * same token.
-     */
-    readonly chain: string[];
-    constructor(chain: string[]);
-}
-
-/**
- * The key of the phantom type of a computed value, apart from a ref's, so
- * that a ref's type is never inferred from a computed value's.
- */
-declare const COMPUTES: unique symbol;
-
-/**
- * A token's value as it was configured, or last given to `set()`, with its
- * refs and computed values unresolved. A token of a library made by
- * `extend()` that isn't given a value has its source token's.
- *
- * @remarks
- * A token's `$value` is resolved, so it can't tell a value that is given from
- * one that is derived from other tokens, or say where in a value a ref is. A
- * tool that reads how a library is configured finds the refs in this value
- * with {@link isRef} and the computed values with {@link isComputed}: a value
- * with neither, at any depth, is given. A converter that writes a ref as a
- * CSS `var()`, rather than its token's value, reads the ref here and its
- * path with {@link pathOf}.
- *
- * It's the value the token holds, not a copy, so it isn't frozen. Changing it
- * doesn't change the token: give a new value to `set()`. Refs and computed
- * values are searched for in plain data, as the library resolves them, and
- * not in a class instance or a function.
- *
- * @example
- * ```ts
- * const isGiven = (value: unknown): boolean =>
- *     !isRef(value) &&
- *     !isComputed(value) &&
- *     (typeof value !== "object" || value === null ||
- *         Object.values(value).every(isGiven));
- *
- * isGiven(configuredValueOf(library.tokens.colors.primary)); // true
- * isGiven(configuredValueOf(library.tokens.colors.hover)); // false: a recipe
- * ```
- *
- * @public
- */
-export declare const configuredValueOf: <T extends DesignToken.Shape, R extends {}, G extends string = never>(token: Library.Token<T, R, G>) => Library.ConfigTokenValue<T, R> | DesignToken.ReadonlyValueByToken<T>;
-
-/**
- * Converts a value of a standard type to CSS, the way {@link toCSS} does for a
- * token of the type, without a converter for the type in `converters`.
- *
- * @remarks
- * A converter for a custom type that has values of standard types uses it for
- * each of them, and a converter for a standard type can use it for what it
- * keeps.
- *
- * @example
- * ```ts
- * toCSS(library, {
- *     converters: {
- *         elevation: (value) =>
- *             `${convert("dimension", value.offset)} ${convert("color", value.color)}`,
- *     },
- * });
- * ```
- *
- * @param type - The type, like `"color"`
- * @param value - The value of a token of the type
- * @returns The value as it is written to CSS
- *
- * @public
- */
-export declare function convert<Name extends keyof DesignToken.ReadonlyValueByType>(type: Name, value: DesignToken.ReadonlyValueByType[Name]): string;
-
-/**
- * @public
- */
-export declare type ConvertersOf<C> = {
-    [N in C extends {
-        $type: infer N extends string;
-    } ? N : never]: C extends {
-        $type: N;
-    } ? C extends DesignToken.Shape ? CSSConverter<DesignToken.ReadonlyValueByToken<C>, C> : never : never;
-};
-
-/**
- * Converts a token value to a CSS value.
- *
- * @remarks
- * A string is the value of the token's custom property, and is the same as
- * `{ "": value }`. A converter returns {@link CSSValues} to write a token as
- * more than one property, such as a value for each state of a component, or
- * a typography value as a property for each of its fields. An empty record
- * writes none.
- *
- * @public
- */
-export declare type CSSConverter<V, T extends DesignToken.Shape = DesignToken.Shape> = (value: V, token: Library.Token<T, {}>) => CSSValue;
-
-/**
- * What a library of shape `T` accepts for each custom token type: a
- * {@link CSSConverter}, or `false` for a type that is not serialized.
- *
- * @public
- */
-export declare type CSSConverterEntries<T> = {
-    [N in keyof CSSConverters<T>]: CSSConverters<T>[N] | false;
-};
-
-/**
- * A {@link CSSConverter} for each custom token type in a library of shape `T`,
- * keyed by type name.
- *
- * @public
- */
-export declare type CSSConverters<T> = ConvertersOf<CustomTokensOf<T>>;
-
-/**
- * Options accepted by {@link toCSS}.
- *
- * @remarks
- * `converters` is required when the library contains custom token types,
- * and must have an entry for each of them: a converter, or `false` for a type
- * whose tokens are not written to CSS.
- * It can have a converter for a standard type as well, which is used in place
- * of the one of the library, see {@link convert} for what it does.
- *
- * @public
- */
-export declare type CSSOptions<T> = CSSPropertiesOptions & ([CustomTokensOf<T>] extends [never] ? {
-    converters?: StandardConverters;
-} : {
-    converters: CSSConverterEntries<T> & StandardConverters;
-});
-
-/**
- * A collection of {@link CSSPropertyValues} (`var` and `property` per token) that mirrors the
- * structure of the source {@link (Library:namespace).Library}.
- *
- * @remarks
- * `C` is the converters given to {@link toProperties}, which name the
- * properties of a token written as more than one, see {@link CSSPropertiesOf}.
- *
- * @public
- */
-export declare type CSSPropertiesLibrary<T extends {}, C = {}> = {
-    [K in keyof Readonly<T>]: T[K] extends DesignToken.Shape ? CSSPropertiesOf<T[K], C> : K extends keyof DesignToken.Group ? T[K] : T[K] extends {} ? CSSPropertiesLibrary<T[K], C> : never;
-};
-
-/**
- * The {@link CSSPropertyValues} of a token of shape `T`, given the
- * converters `C`: one for its property, or one for each key of the
- * {@link CSSValues} its converter returns, where `""` is the token's own.
- *
- * @remarks
- * The keys are known when the return type of the converter is inferred.
- * When it isn't, such as for a converter typed {@link CSSConverter}, the
- * token has the property of its own in the type, and the others at runtime.
- *
- * @public
- */
-export declare type CSSPropertiesOf<T, C = {}> = T extends {
-    $type: infer N extends keyof C;
-} ? C[N] extends (...args: any[]) => infer V ? V extends string ? CSSPropertyValues : string extends keyof V ? CSSPropertyValues : ("" extends keyof V ? CSSPropertyValues : {}) & {
-    readonly [P in Exclude<keyof V, "">]: CSSPropertyValues;
-} : CSSPropertyValues : CSSPropertyValues;
-
-/**
- * Options that control how custom properties are named.
- *
- * @public
- */
-export declare interface CSSPropertiesOptions {
-    /**
-     * Derives a token's custom property name, without the leading `--`.
-     *
-     * @remarks
-     * Defaults to the token's name with `.` replaced by `-`. Pass the same
-     * function to {@link toCSS} and {@link toProperties} to keep the names
-     * aligned.
-     */
-    name?(token: Library.Token<any, any>): string;
-}
-
-/**
- * @public
- */
-export declare interface CSSPropertyValues {
-    readonly var: `var(--${string})`;
-    readonly property: `--${string}`;
-}
-
-/**
- * What a {@link CSSConverter} returns: the value of the token's custom
- * property, or {@link CSSValues} for a token written as more than one.
- *
- * @public
- */
-export declare type CSSValue = string | CSSValues;
-
-/**
- * The values of the custom properties of a token, by what is added to the
- * name of the token's property with `-`: `""` is the token's own property,
- * and `hover` is `--fill-hover` for a token named `fill`.
- *
- * @public
- */
-export declare type CSSValues = {
-    readonly [suffix: string]: string;
-};
-
-/**
- * A union of the custom tokens in a library of shape `T`: tokens whose
- * type is not defined by {@link https://www.designtokens.org/tr/2025.10/format/#types}.
- *
- * @public
- */
-export declare type CustomTokensOf<T> = Exclude<Library.TokensOf<T>, {
-    $type?: DesignToken.Type;
-}>;
-
-/**
- * The tokens that a token's value refers to, through refs anywhere in its
- * configured value, including the arguments of the recipes it's computed
- * with, in the token's library. Each token is listed once, in the order its
- * first ref is in the value.
- *
- * @remarks
- * These are the tokens the value is made from, and not theirs in turn: a
- * tool follows each with `dependenciesOf()` for the whole chain. A value
- * computed by a recipe from literal arguments only has no dependencies,
- * though it's derived: {@link configuredValueOf} tells that apart.
- *
- * It throws when a ref's path isn't a token of the library, as reading the
- * token's `$value` does.
- *
- * @example
- * ```ts
- * // hover: { $value: Recipes.darken(theme.colors.primary, 0.2) }
- * dependenciesOf(library.tokens.colors.hover).map((token) => token.name);
- * // ["colors.primary"]
- * ```
- *
- * @public
- */
-export declare const dependenciesOf: <T extends DesignToken.Shape, R extends {}, G extends string = never>(token: Library.Token<T, R, G>) => ReadonlyArray<Library.TokenRecord<R>>;
-
-/**
- * The tokens whose values refer to a token, through refs anywhere in their
- * configured values, including the arguments of their recipes, in the
- * token's library. It is the reverse of {@link dependenciesOf}: each token is
- * listed once, in the order of the library.
- *
- * @remarks
- * These are the tokens that refer to the token directly. A token whose value
- * may change when this one is set is also one that refers to one of those: a
- * tool follows each with `dependentsOf()` for the whole set, as it follows
- * {@link dependenciesOf} for the chain the other way.
- *
- * This reads the configured values and not the values, so it resolves no
- * token, and so it is known of a library whose tokens have not been read. It
- * is found for the whole library once and kept until a token is set to a
- * different value, so each call after the first is a lookup. A value a recipe
- * reads other than through its arguments is not seen, as for
- * {@link dependenciesOf}.
- *
- * It throws when a ref in a token of the library isn't a token of it, as
- * reading the token's `$value` does.
- *
- * @example
- * ```ts
- * // hover: { $value: Recipes.darken(theme.colors.primary, 0.2) }
- * dependentsOf(library.tokens.colors.primary).map((token) => token.name);
- * // ["colors.hover"]
- *
- * // Every token that may change when a token is set
- * const affected = new Set<Library.Token<any, any>>();
- * const visit = (token: Library.Token<any, any>) => {
- *     for (const dependent of dependentsOf(token)) {
- *         if (!affected.has(dependent)) {
- *             affected.add(dependent);
- *             visit(dependent);
- *         }
- *     }
- * };
- * visit(extension.tokens.color.context);
- * ```
- *
- * @public
- */
-export declare const dependentsOf: <T extends DesignToken.Shape, R extends {}, G extends string = never>(token: Library.Token<T, R, G>) => ReadonlyArray<Library.TokenRecord<R>>;
-
-/**
- * @public
- */
-export declare namespace DesignToken {
-    /**
-     * An enumeration of all supported types defined
-     * by {@link https://www.designtokens.org/tr/2025.10/format/#types}
-     */
-    export enum Type {
-        Border = "border",
-        Color = "color",
-        CubicBezier = "cubicBezier",
-        Dimension = "dimension",
-        Duration = "duration",
-        FontFamily = "fontFamily",
-        FontWeight = "fontWeight",
-        Gradient = "gradient",
-        Number = "number",
-        Shadow = "shadow",
-        StrokeStyle = "strokeStyle",
-        Transition = "transition",
-        Typography = "typography"
-    }
-    /**
-     * The values supported for each {@link DesignToken.Type | DesignToken type}.
-     */
-    export namespace Values {
-        /**
-         * The color spaces of the {@link https://www.designtokens.org/tr/2025.10/color/ | Color module}.
-         */
-        export type ColorSpace = "srgb" | "srgb-linear" | "hsl" | "hwb" | "lab" | "lch" | "oklab" | "oklch" | "display-p3" | "a98-rgb" | "prophoto-rgb" | "rec2020" | "xyz-d65" | "xyz-d50";
-        /**
-         * A color component: a number, or `"none"` for a missing component.
-         */
-        export type ColorComponent = Values.Number | "none";
-        /**
-         * A color in a color space. Every color space has three components,
-         * whose ranges depend on the color space.
-         *
-         * @see {@link https://www.designtokens.org/tr/2025.10/color/}
-         */
-        export interface Color {
-            colorSpace: ColorSpace;
-            components: [ColorComponent, ColorComponent, ColorComponent];
-            /**
-             * From 0 (transparent) to 1 (opaque). Defaults to 1.
-             */
-            alpha?: Values.Number;
-            /**
-             * A fallback in six digit CSS hex notation.
-             */
-            hex?: `#${string}`;
-        }
-        /**
-         * A number with a unit, which is required even when the number is 0.
-         *
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#dimension}
-         */
-        export interface Dimension {
-            value: Values.Number;
-            unit: "px" | "rem";
-        }
-        /**
-         * The name of the font family, or an array of names in order of
-         * preference.
-         *
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#font-family}
-         */
-        export type FontFamily = string | string[];
-        /**
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#number}
-         */
-        export type Number = number;
-        /**
-         * A number from 1 to 1000, or a font-weight keyword.
-         *
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#font-weight}
-         */
-        export type FontWeight = Values.Number | "thin" | "hairline" | "extra-light" | "ultra-light" | "light" | "normal" | "regular" | "book" | "medium" | "semi-bold" | "demi-bold" | "bold" | "extra-bold" | "ultra-bold" | "black" | "heavy" | "extra-black" | "ultra-black";
-        /**
-         * A length of time in milliseconds or seconds.
-         *
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#duration}
-         */
-        export interface Duration {
-            value: Values.Number;
-            unit: "ms" | "s";
-        }
-        /**
-         * Cubic Bézier coordinates. The x coordinates are within [0, 1].
-         *
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#cubic-bezier}
-         */
-        export type CubicBezier = [
-        P1x: Values.Number,
-        P1y: Values.Number,
-        P2x: Values.Number,
-        P2y: Values.Number
-        ];
-        /**
-         * One shadow.
-         *
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#shadow}
-         */
-        export interface ShadowLayer {
-            color: Values.Color;
-            offsetX: Values.Dimension;
-            offsetY: Values.Dimension;
-            blur: Values.Dimension;
-            spread: Values.Dimension;
-            /**
-             * An inner shadow. Defaults to `false`.
-             */
-            inset?: boolean;
-        }
-        /**
-         * One shadow, or several layered shadows.
-         *
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#shadow}
-         */
-        export type Shadow = ShadowLayer | ShadowLayer[];
-        /**
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#stroke-style}
-         */
-        export type StrokeStyle = "solid" | "dashed" | "dotted" | "double" | "groove" | "ridge" | "outset" | "inset" | {
-            dashArray: Values.Dimension[];
-            lineCap: "round" | "butt" | "square";
-        };
-        /**
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#border}
-         */
-        export interface Border {
-            color: Values.Color;
-            width: Values.Dimension;
-            style: Values.StrokeStyle;
-        }
-        /**
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#transition}
-         */
-        export interface Transition {
-            duration: Values.Duration;
-            delay: Values.Duration;
-            timingFunction: Values.CubicBezier;
-        }
-        /**
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#gradient}
-         * @remarks
-         * Position values must be a number within [0, 1].
-         */
-        export type Gradient = Array<{
-            color: Values.Color;
-            position: Values.Number;
-        }>;
-        /**
-         * @see {@link https://www.designtokens.org/tr/2025.10/format/#typography}
-         */
-        export interface Typography {
-            fontFamily: Values.FontFamily;
-            fontSize: Values.Dimension;
-            fontWeight: Values.FontWeight;
-            letterSpacing: Values.Dimension;
-            lineHeight: Values.Number;
-        }
-        /**
-         * The readonly form of each value, as returned by a library token.
-         */
-        export namespace Readonly {
-            export interface Border extends DeepReadonly<Values.Border> {
-            }
-            export interface Color extends DeepReadonly<Values.Color> {
-            }
-            export type CubicBezier = DeepReadonly<Values.CubicBezier>;
-            export interface Dimension extends DeepReadonly<Values.Dimension> {
-            }
-            export interface Duration extends DeepReadonly<Values.Duration> {
-            }
-            export type FontFamily = DeepReadonly<Values.FontFamily>;
-            export type FontWeight = DeepReadonly<Values.FontWeight>;
-            export type Gradient = DeepReadonly<Values.Gradient>;
-            export type Number = DeepReadonly<Values.Number>;
-            export type Shadow = DeepReadonly<Values.Shadow>;
-            export type StrokeStyle = DeepReadonly<Values.StrokeStyle>;
-            export interface Transition extends DeepReadonly<Values.Transition> {
-            }
-            export interface Typography extends DeepReadonly<Values.Typography> {
-            }
-        }
-    }
-    /**
-     * The value type of each {@link DesignToken.Type}, keyed by its name, like
-     * `color`.
-     */
-    export interface ValueByType {
-        border: Values.Border;
-        color: Values.Color;
-        cubicBezier: Values.CubicBezier;
-        dimension: Values.Dimension;
-        duration: Values.Duration;
-        fontFamily: Values.FontFamily;
-        fontWeight: Values.FontWeight;
-        gradient: Values.Gradient;
-        number: Values.Number;
-        shadow: Values.Shadow;
-        strokeStyle: Values.StrokeStyle;
-        transition: Values.Transition;
-        typography: Values.Typography;
-    }
-    /**
-     * `T` with every nested property, array, and array item readonly.
-     */
-    export type DeepReadonly<T> = T extends Function ? T : {
-        readonly [K in keyof T]: DeepReadonly<T[K]>;
-    };
-    /**
-     * The readonly value type of each {@link DesignToken.Type}, keyed by its
-     * name, like `color`: the value a library token of the type returns.
-     */
-    export interface ReadonlyValueByType {
-        border: Values.Readonly.Border;
-        color: Values.Readonly.Color;
-        cubicBezier: Values.Readonly.CubicBezier;
-        dimension: Values.Readonly.Dimension;
-        duration: Values.Readonly.Duration;
-        fontFamily: Values.Readonly.FontFamily;
-        fontWeight: Values.Readonly.FontWeight;
-        gradient: Values.Readonly.Gradient;
-        number: Values.Readonly.Number;
-        shadow: Values.Readonly.Shadow;
-        strokeStyle: Values.Readonly.StrokeStyle;
-        transition: Values.Readonly.Transition;
-        typography: Values.Readonly.Typography;
-    }
-    /**
-     * All properties supported by a DesignToken
-     */
-    export interface Properties<Type extends DesignToken.Type, Value extends DesignToken.Values.Any> {
-        $description?: string;
-        /**
-         * The token's type. In a {@link (Library:namespace).Config}, it may be omitted
-         * when it's inherited from an ancestor group.
-         */
-        $type: Type;
-        $extensions?: Record<string, any>;
-        /**
-         * `true`, or a string explaining why, when the token is deprecated.
-         */
-        $deprecated?: boolean | string;
-        $value: Value;
-    }
-    export type Border = Properties<DesignToken.Type.Border, DesignToken.Values.Border>;
-    export type Color = Properties<DesignToken.Type.Color, DesignToken.Values.Color>;
-    export type CubicBezier = Properties<DesignToken.Type.CubicBezier, DesignToken.Values.CubicBezier>;
-    export type Dimension = Properties<DesignToken.Type.Dimension, DesignToken.Values.Dimension>;
-    export type Duration = Properties<DesignToken.Type.Duration, DesignToken.Values.Duration>;
-    export type FontFamily = Properties<DesignToken.Type.FontFamily, DesignToken.Values.FontFamily>;
-    export type FontWeight = Properties<DesignToken.Type.FontWeight, DesignToken.Values.FontWeight>;
-    export type Gradient = Properties<DesignToken.Type.Gradient, DesignToken.Values.Gradient>;
-    export type Number = Properties<DesignToken.Type.Number, DesignToken.Values.Number>;
-    export type Shadow = Properties<DesignToken.Type.Shadow, DesignToken.Values.Shadow>;
-    export type StrokeStyle = Properties<DesignToken.Type.StrokeStyle, DesignToken.Values.StrokeStyle>;
-    export type Transition = Properties<DesignToken.Type.Transition, DesignToken.Values.Transition>;
-    export type Typography = Properties<DesignToken.Type.Typography, DesignToken.Values.Typography>;
-    /**
-     * Type names reserved by {@link https://www.designtokens.org/tr/2025.10/format/#types}.
-     * Custom types cannot use these names.
-     */
-    export type ReservedTypeName = `${DesignToken.Type}`;
-    /**
-     * A token of a custom type that is not defined by
-     * {@link https://www.designtokens.org/tr/2025.10/format/#types}.
-     *
-     * @remarks
-     * `Name` identifies the type and must not be a {@link DesignToken.ReservedTypeName}.
-     * `Value` can be any type, such as a plain object, a class instance, or an
-     * object with methods. The library returns the value as it is, and never
-     * calls its functions. A config can give the value, or any property of
-     * plain data in it, as a {@link ref} or a {@link recipes | computed value}.
-     *
-     * @example
-     * ```ts
-     * interface Elevation { level: number; shadow: DesignToken.Values.Shadow }
-     * type ElevationToken = DesignToken.Custom<"elevation", Elevation>;
-     * ```
-     */
-    export interface Custom<Name extends string, Value> {
-        $description?: string;
-        $type: CustomTypeName<Name>;
-        $extensions?: Record<string, any>;
-        $deprecated?: boolean | string;
-        $value: Value;
-    }
-    /**
-     * A group of DesignTokens.
-     */
-    export type Group = {
-        /**
-         * If the group has a type, the type is inferred for all descendent design tokens,
-         * unless specified by the token.
-         */
-        $type?: string;
-        $description?: string;
-        $extensions?: Record<string, any>;
-        $deprecated?: boolean | string;
-    };
-}
-
-/**
- * The tokens and groups of a library, each with its path, in the order of
- * the config. A group is listed before the tokens and groups in it.
- *
- * @remarks
- * This is the library's own rule for what is a token and what is a group, and
- * for which keys are children, so a tool that visits every token (an index, a
- * report, a list of the tokens to offer for a property) doesn't walk
- * `library.tokens` and restate it. It walks as a DOM `TreeWalker` does: an
- * entry that `whatToShow` leaves out is not passed to `filter`, but what is
- * under it is still visited, and `filter` can return `"reject"` to leave out
- * a group and everything under it.
- *
- * The library itself isn't listed, as a `TreeWalker`'s root isn't, so its own
- * `$`-prefixed properties are not visited. A group's own token is listed with
- * the path of its group and `$root`.
- *
- * The order is the order of the keys in a JavaScript object, so a name that
- * is an array index (`"0"`, `"123"`) is listed before the other names of its
- * group, in ascending order, whatever its place in the config.
- *
- * The listing is lazy and reads the
- * library as it goes; a token's `$value` is not read.
- *
- * @example
- * ```ts
- * // The names of every token that isn't deprecated, in a group that isn't
- * for (const { token } of entriesOf(library, {
- *     whatToShow: "token",
- *     filter: ({ token }) => !token.$deprecated,
- * })) {
- *     names.push(token.name);
- * }
- *
- * // Everything, leaving out the deprecated groups
- * const entries = [
- *     ...entriesOf(library, {
- *         filter: (entry) =>
- *             entry.kind === "group" && entry.group.$deprecated
- *                 ? "reject"
- *                 : true,
- *     }),
- * ];
- * ```
- *
- * @public
- */
-export declare function entriesOf<T extends {}, R extends {}>(library: Library.Library<T, R>, options: Library.EntriesOptions<"token", R> & {
-    whatToShow: "token";
-}): Generator<Library.TokenEntry<R>, void, undefined>;
-
-/** @public */
-export declare function entriesOf<T extends {}, R extends {}>(library: Library.Library<T, R>, options: Library.EntriesOptions<"group", R> & {
-    whatToShow: "group";
-}): Generator<Library.GroupEntry, void, undefined>;
-
-/** @public */
-export declare function entriesOf<T extends {}, R extends {}>(library: Library.Library<T, R>, options?: Library.EntriesOptions<"all", R>): Generator<Library.EntryOf<"all", R>, void, undefined>;
-
-/**
- * Builds a 2025.10 sRGB color from a hex color string: `#RGB`, `#RRGGBB` or
- * `#RRGGBBAA`.
- *
- * @throws A `TypeError` when the string is not a hex color.
- *
- * @public
- */
-export declare const hex: (css: string) => DesignToken.Values.Color;
-
-/**
- * Tests whether a value is a {@link (Library:namespace).Computed} value, a
- * recipe's result, also one made by another copy of this package.
- *
- * @remarks
- * The library computes a value anywhere in a token's value. A tool that reads
- * a token's value as configured, with {@link configuredValueOf}, tells a
- * computed value from other values with `isComputed()`, as it tells a ref
- * with {@link isRef}.
- *
- * A computed value is a `Computed<unknown, never>` whatever its result and
- * library, so a value typed as a computed value of a library is narrowed to
- * it.
- *
- * @example
- * ```ts
- * isComputed(Recipes.darken(ref("colors.primary"), 0.2)); // true
- * isComputed(hex("#0000ff")); // false
- * ```
- *
- * @public
- */
-export declare const isComputed: (value: unknown) => value is Library.Computed<unknown, never>;
-
-/**
- * Tests whether a value is a {@link (Library:namespace).Ref}, made by
- * {@link ref} or {@link refs}, also by another copy of this package.
- *
- * @remarks
- * The library resolves a ref anywhere in a value. An add-on that keeps a
- * ref, rather than its token's value, tells it from other values with
- * `isRef()`, and reads its path with {@link pathOf}.
- *
- * A ref is a `Ref<unknown, never>` whatever its token and library, so a
- * value typed as a ref of a library is narrowed to that ref.
- *
- * @example
- * ```ts
- * isRef(ref("colors.primary")); // true
- * isRef(hex("#0000ff")); // false
- * ```
- *
- * @public
- */
-export declare const isRef: (value: unknown) => value is Library.Ref<unknown, never>;
-
-/**
- * @public
- */
-export declare namespace Library {
-    export interface Library<T extends {}, R extends {} = T> {
-        tokens: TokenLibrary<T, R>;
-        subscribe(subscriber: Library.Subscriber<R>): void;
-        unsubscribe(subscriber: Library.Subscriber<R>): void;
-        /**
-         * Creates a library with the values of the tokens replaced, and
-         * recipes overridden.
-         *
-         * @remarks
-         * This has no tokens to add, so a value is checked against the type
-         * of its token wherever the token is.
-         *
-         * A token of the extension is made when it is first read, and an
-         * extension that nothing refers to is collected, along with its
-         * subscribers.
-         */
-        extend(config: ExtendConfig<T, R>, options?: ExtendOptions): Library<T, R>;
-        /**
-         * Creates a library with the values of tokens replaced, new tokens,
-         * and recipes overridden.
-         *
-         * @remarks
-         * A token of the extension is made when it is first read, and an
-         * extension that nothing refers to is collected, along with its
-         * subscribers.
-         */
-        extend<K extends NoRoot<K> = {}>(config: ExtendConfig<T, R & NewTokens<K, T>> & Config<K, R & NewTokens<K, T>, never, T> & NoInfer<ConfigValueCheck<K, R & NewTokens<K, T>>> & (ConfigTypeHint | {}), options?: ExtendOptions): Library<T & NewTokens<K, T>, R & NewTokens<K, T>>;
-    }
-    /**
-     * The tokens and groups of `K` that are new relative to a source library
-     * of shape `T`. Overrides of tokens in `T` are removed so that they keep
-     * the source token's type.
-     *
-     * @public
-     */
-    export type NewTokens<K, T> = {
-        [P in keyof K as P extends keyof T ? T[P] extends DesignToken.Shape ? never : P : P]: P extends keyof T ? NewTokens<K[P], T[P]> : K[P];
-    };
-    /**
-     * `$root` is the token of a group, so a library cannot have one at its top
-     * level, where there is no group to name it for.
-     *
-     * @public
-     */
-    export type NoRoot<T> = {
-        [K in keyof T]: K extends "$root" ? never : T[K];
-    };
-    /**
-     * Which entries of a library {@link (entriesOf:3)} lists: its tokens, its
-     * groups, or both. Each is the `kind` of the entries it lists.
-     *
-     * @public
-     */
-    export type Show = "all" | "token" | "group";
-    /**
-     * A token of a library, with the path of keys that leads to it from the
-     * root. The path of a group's own token ends with `$root`.
-     *
-     * @public
-     */
-    export interface TokenEntry<R extends {}> {
-        readonly kind: "token";
-        readonly path: readonly string[];
-        readonly token: TokenRecord<R>;
-    }
-    /**
-     * A group of a library, with the path of keys that leads to it from the
-     * root. The group has the `$`-prefixed properties it was configured with.
-     *
-     * @public
-     */
-    export interface GroupEntry {
-        readonly kind: "group";
-        readonly path: readonly string[];
-        readonly group: Readonly<DesignToken.Group>;
-    }
-    /**
-     * The entries that {@link (entriesOf:3)} lists for `S`.
-     *
-     * @public
-     */
-    export type EntryOf<S extends Show, R extends {}> = S extends "token" ? TokenEntry<R> : S extends "group" ? GroupEntry : TokenEntry<R> | GroupEntry;
-    /**
-     * What a {@link (entriesOf:3)} filter returns for an entry: `true` lists it,
-     * `false` leaves it out, and `"reject"` leaves it out along with
-     * everything under it.
-     *
-     * @public
-     */
-    export type FilterResult = boolean | "reject";
-    /**
-     * @public
-     */
-    export interface EntriesOptions<S extends Show, R extends {}> {
-        /**
-         * The kind of entries to list. Groups are visited, and their tokens
-         * listed, whichever it is. By default, all.
-         */
-        readonly whatToShow?: S;
-        /**
-         * Called with each entry of the kinds shown, before its children are
-         * visited.
-         */
-        filter?(entry: EntryOf<S, R>): FilterResult;
-    }
-    export interface Subscriber<R extends {}> {
-        onChange(records: ReadonlyArray<Library.TokenRecord<R>>): void;
-    }
-    /**
-     * A union of all tokens in a library of shape `T`.
-     *
-     * @public
-     */
-    export type TokensOf<T> = {
-        [K in keyof T]-?: T[K] extends DesignToken.Shape ? T[K] : K extends keyof DesignToken.Group ? never : T[K] extends object ? TokensOf<T[K]> : never;
-    }[keyof T];
-    /**
-     * A {@link (Library:namespace).Token} of any token in a library of shape `R`.
-     * The union is discriminated by `type`.
-     *
-     * @public
-     */
-    export type TokenRecord<R extends {}> = TokensOf<R> extends infer T ? T extends DesignToken.Shape ? Token<T, R> : never : never;
-    /**
-     * Defines a token library that can be interacted with
-     * to mutate token values.
-     *
-     * @remarks
-     * `G` is the type inherited from ancestor groups.
-     *
-     * @public
-     */
-    export type TokenLibrary<T extends {}, R extends {} = T, G extends string = never> = TokenGroup<T, R, GroupType<T, G>>;
-    export type TokenGroup<T extends {}, R extends {}, G extends string> = {
-        [K in keyof Readonly<T>]: T[K] extends DesignToken.Shape ? Token<T[K], R, G> : K extends keyof DesignToken.Group ? T[K] : T[K] extends {} ? TokenLibrary<T[K], R, G> : never;
-    };
-    /**
-     * The value type of each token of a library of shape `T`, by its path.
-     * Refs and computed values are typed by it, so they're given only to a
-     * library that has their tokens, with values of the same types, whether
-     * its shape is declared or inferred from its config.
-     *
-     * @public
-     */
-    export type TokenValues<T> = {
-        [K in keyof T as K extends keyof DesignToken.Group ? never : K]: T[K] extends DesignToken.Shape ? TokenValue<DesignToken.ValueByToken<T[K]>> : T[K] extends object ? TokenValues<T[K]> : never;
-    };
-    /**
-     * A token with a value of type `V`, in
-     * {@link (Library:namespace).TokenValues}. It's only a type: it marks
-     * where a path ends at a token rather than going into its value.
-     *
-     * @public
-     */
-    export interface TokenValue<V> {
-        readonly [TOKEN]: V;
-    }
-    /**
-     * The dotted path of each token in `T`, the
-     * {@link (Library:namespace).TokenValues} of a library, whose value is a
-     * `V`. These are the paths {@link ref} takes where a `V` is expected.
-     *
-     * @public
-     */
-    export type TokenPath<T, V> = {
-        [K in keyof T & string]: T[K] extends TokenValue<infer W> ? [W] extends [V] ? K : never : `${K}.${TokenPath<T[K], V>}`;
-    }[keyof T & string];
-    /**
-     * A reference to a token whose value is of type `V`, in a library whose
-     * token values are `T`. It's resolved to the token's value when the token
-     * that has it is read. Made by {@link ref} and {@link refs}.
-     *
-     * @remarks
-     * A ref is data: the path of its token. `T`, the
-     * {@link (Library:namespace).TokenValues} of the library, is only in its
-     * type, so that a ref can only be given to a library that has its token.
-     *
-     * @public
-     */
-    export interface Ref<V, T> {
-        readonly [REF]: readonly string[];
-        readonly [RESOLVES]?: (library: T) => V;
-    }
-    /**
-     * A value of type `V` computed by a {@link (Library:namespace).Recipe}
-     * from its arguments, which may refer to the tokens of a library whose
-     * {@link (Library:namespace).TokenValues} are `T`. It's computed when the
-     * token that has it is read.
-     *
-     * @remarks
-     * A computed value is data: the recipe and its arguments.
-     *
-     * @public
-     */
-    export interface Computed<V, T> {
-        readonly [COMPUTED]: {
-            readonly recipe: Recipe<any, unknown>;
-            readonly args: readonly unknown[];
-        };
-        readonly [COMPUTES]?: (library: T) => V;
-    }
-    /**
-     * A value of type `V` in a configuration: the value, a
-     * {@link (Library:namespace).Ref}, a {@link (Library:namespace).Computed}
-     * value, or, when `V` is an object or an array, `V` with any of its
-     * properties and elements, at any depth, given as one of those.
-     *
-     * @remarks
-     * Its objects and arrays may be readonly, as a token's value is, so a
-     * token's value can be given where a config takes a value, as `set()`
-     * takes it. A computed value may be readonly, as a recipe's function that
-     * takes readonly arguments returns: the library copies and freezes a
-     * recipe's result.
-     *
-     * @public
-     */
-    export type DeepValue<V, T> = V | Ref<V, T> | Computed<DesignToken.DeepReadonly<V>, T> | (V extends object ? {
-        readonly [K in keyof V]: DeepValue<V[K], T>;
-    } : never);
-    /**
-     * The arguments of a {@link (Library:namespace).Recipe} whose function has
-     * the parameters `A`. Each may be a ref, a computed value, or a value with
-     * them in it.
-     *
-     * @public
-     */
-    export type RecipeArguments<A extends readonly unknown[], T> = {
-        [K in keyof A]: DeepValue<A[K], T>;
-    };
-    /**
-     * A function, made by {@link recipes}, that takes the arguments of a
-     * function with parameters `A` and result `V`, any of which may refer to
-     * tokens, and returns the {@link (Library:namespace).Computed} result.
-     * `T` is the token values of the library its arguments refer to.
-     *
-     * @remarks
-     * A recipe has its name and its function, which a library that extends
-     * another can override with {@link override}. The function gets each
-     * argument as a token gets its value: a ref's value, and a copy of plain
-     * data, which are frozen, and anything else as it is. So its parameters
-     * are typed readonly, as in `DesignToken.Values.Readonly.Color`.
-     *
-     * @public
-     */
-    export type Recipe<A extends readonly unknown[], V> = (<T extends {} = {}>(...args: RecipeArguments<A, T>) => Computed<V, T>) & {
-        readonly [RECIPE]: {
-            readonly name: string;
-            readonly fn: (...args: A) => V;
-        };
-    };
-    /**
-     * The {@link (Library:namespace).Recipe | recipes} of the functions of `F`,
-     * by the same keys. Made by {@link recipes}.
-     *
-     * @public
-     */
-    export type Recipes<F extends Record<string, (...args: any[]) => unknown>> = {
-        readonly [K in keyof F]: Recipe<Parameters<F[K]>, ReturnType<F[K]>>;
-    };
-    /**
-     * A function that replaces a recipe's in a library made by `extend()`.
-     * Made by {@link override}.
-     *
-     * @public
-     */
-    export interface RecipeOverride {
-        readonly recipe: Recipe<any, unknown>;
-        readonly fn: (...args: any[]) => unknown;
-    }
-    /**
-     * Options of `extend()`.
-     *
-     * @public
-     */
-    export interface ExtendOptions {
-        /**
-         * Recipes whose function is replaced in the new library, for every
-         * token that computes its value with them, including the tokens it
-         * doesn't restate.
-         */
-        readonly recipes?: readonly RecipeOverride[];
-    }
-    /**
-     * A {@link (Library:namespace).Ref} to each token of a library of shape
-     * `R`, at the path of the token in `T`, the shape of a group of it. Made by
-     * {@link refs}.
-     *
-     * @public
-     */
-    export type Refs<T extends {}, R extends {} = T> = {
-        readonly [K in keyof T as K extends keyof DesignToken.Group ? never : K]-?: T[K] extends DesignToken.Shape ? Ref<DesignToken.ValueByToken<T[K]>, TokenValues<R>> : T[K] extends {} ? Refs<T[K], R> : never;
-    };
-    /**
-     * A token in a {@link (Library:namespace).TokenLibrary}
-     *
-     * @remarks
-     * `G` is the type inherited from ancestor groups, used when
-     * `T` does not declare a `$type`.
-     *
-     * @public
-     */
-    export type Token<T extends DesignToken.Shape, C extends {}, G extends string = never> = {
-        set(value: ConfigTokenValue<T, C> | DesignToken.ReadonlyValueByToken<T>): void;
-        /**
-         * A JSON representation of the token's name, type, resolved value,
-         * description, extensions and deprecation.
-         */
-        toString(): string;
-        readonly $type: DesignToken.TypeByToken<T, G>;
-        readonly $extensions: Record<string, any>;
-        readonly $value: DesignToken.ReadonlyValueByToken<T>;
-        readonly $description: string;
-        /**
-         * `false`, `true`, or the explanation the token was deprecated with.
-         */
-        readonly $deprecated: boolean | string;
-        readonly name: string;
-    };
-    export type IsUnion<T, U = T> = T extends unknown ? [U] extends [T] ? false : true : never;
-    /**
-     * The type a group passes on to its descendant tokens, following
-     * {@link https://www.designtokens.org/tr/2025.10/format/#type-1 | DTCG group type inheritance}.
-     *
-     * @remarks
-     * A group passes on its own `$type` only when the group's shape declares a
-     * required, single, literal `$type`. A group with an optional or non-literal
-     * `$type` may set any type at runtime, so it passes on nothing. A group
-     * without a `$type` passes on its ancestor's type, `G`.
-     *
-     * @public
-     */
-    export type GroupType<T, G extends string = never> = "$type" extends keyof T ? {} extends Pick<T, "$type"> ? never : T["$type"] extends string ? string extends T["$type"] ? never : true extends IsUnion<T["$type"]> ? never : T["$type"] : never : G;
-    /**
-     * The value of a token in a configuration object, in a library of shape
-     * `R`: a {@link (Library:namespace).DeepValue} of the token's value type.
-     *
-     * @public
-     */
-    export type ConfigTokenValue<T extends DesignToken.Shape, R extends {}> = DeepValue<DesignToken.ValueByToken<T>, TokenValues<R>>;
-    /**
-     * A token in a configuration object.
-     *
-     * @remarks
-     * The token's `$type` may only be omitted when it matches the type
-     * inherited from ancestor groups, `G`.
-     *
-     * @public
-     */
-    export type ConfigValue<T extends DesignToken.Shape, R extends {}, G extends string = never> = T | (Omit<T, "$type" | "$value"> & ([G] extends [never] ? {
-        $type: DesignToken.TypeByToken<T>;
-    } : [DesignToken.TypeByToken<T, G>] extends [G] ? {
-        $type?: DesignToken.TypeByToken<T, G>;
-    } : {
-        $type: DesignToken.TypeByToken<T>;
-    }) & {
-        $value: ConfigTokenValue<T, R>;
-    });
-    /**
-     * A configuration object provided to {@link Library.create}
-     *
-     * @remarks
-     * `G` is the type inherited from ancestor groups. `S` is the shape of a
-     * source library being extended: its group types are inherited, and its
-     * tokens may be overridden without restating their type.
-     *
-     * @public
-     */
-    export type Config<T extends {}, R extends {} = T, G extends string = never, S = {}> = ConfigGroup<T, R, GroupType<T, GroupType<S, G>>, S>;
-    export type ConfigGroup<T extends {}, R extends {}, G extends string, S> = {
-        [K in keyof T]: K extends keyof S ? S[K] extends DesignToken.Shape ? unknown : ConfigEntry<T, R, G, S, K> : ConfigEntry<T, R, G, S, K>;
-    };
-    export type ConfigEntry<T extends {}, R extends {}, G extends string, S, K extends keyof T> = T[K] extends DesignToken.Shape ? ConfigValue<T[K], R, G> : K extends keyof DesignToken.Group ? T[K] : T[K] extends {} ? Config<T[K], R, G, K extends keyof S ? S[K] : {}> : T[K] extends null | undefined ? T[K] : never;
-    /**
-     * Checks the `$value` of each token in a config of shape `T` against
-     * its `$type`. It's needed when `T` is inferred from the config, because
-     * the inferred `$value` is the config's own value, so
-     * {@link (Library:namespace).Config} alone can't reject it.
-     *
-     * @remarks
-     * Only the values of tokens that declare a {@link DesignToken.Type} are
-     * checked. A token can't have a child (a key without a `$` prefix).
-     *
-     * Tokens are found by their keys rather than by `T[K] extends Shape`,
-     * which TypeScript doesn't resolve for an inferred `T` with extra keys.
-     * An `any` config, such as `Library.create<any>()`, isn't checked.
-     *
-     * @public
-     */
-    export type ConfigValueCheck<T, R extends {}> = 0 extends 1 & T ? unknown : {
-        [K in keyof T]: 0 extends 1 & T[K] ? unknown : "$value" extends keyof T[K] ? ("$type" extends keyof T[K] ? TokenValueCheck<T[K][Extract<"$type", keyof T[K]>], R> : unknown) & {
-            [P in Exclude<keyof T[K], `$${string}`>]?: never;
-        } : T[K] extends object ? ConfigValueCheck<T[K], R> : unknown;
-    };
-    export type TokenValueCheck<Type, R extends {}> = [Type] extends [
-    keyof DesignToken.ValueByType
-    ] ? {
-        $value: ConfigTokenValue<{
-            $type: Type;
-            $value: DesignToken.ValueByType[Type];
-        }, R>;
-    } : unknown;
-    /**
-     * Gives each `$type` in a config literal a contextual type, so that
-     * TypeScript keeps an inferred `$type` literal, such as
-     * `DesignToken.Type.Color`, instead of widening it to `DesignToken.Type`.
-     * {@link (Library:namespace).ConfigValueCheck} needs the literal.
-     *
-     * @remarks
-     * Configs are typed `ConfigTypeHint | {}`, so a config without an index
-     * signature, such as a typed variable, is still accepted.
-     *
-     * @public
-     */
-    export type ConfigTypeHint = {
-        readonly [key: string]: ConfigTypeHint | DesignToken.Type | (string & {}) | number | boolean | object | null | undefined;
-    };
-    /**
-     * A configuration object provided to {@link (Library:namespace).Library.(extend:1)}.
-     * All tokens and groups of the source library are optional, and token
-     * values may be static values, refs or computed values. Token types are inherited
-     * from the source library.
-     *
-     * @public
-     */
-    export type ExtendConfig<T extends {}, R extends {} = T> = {
-        [K in keyof T]?: T[K] extends DesignToken.Shape ? Omit<T[K], "$type" | "$value"> & {
-            $type?: DesignToken.TypeByToken<T[K]>;
-            $value: ConfigTokenValue<T[K], R>;
-        } : K extends keyof DesignToken.Group ? T[K] : T[K] extends {} ? ExtendConfig<T[K], R> : never;
-    };
-    /**
-     * @public
-     */
-    const create: <T extends NoRoot<T> = any>(config: Library.Config<T, T> & NoInfer<ConfigValueCheck<T, T>> & (ConfigTypeHint | {})) => Library.Library<T>;
-    export {};
-}
-
-/**
- * Builds a duration in milliseconds.
- *
- * @public
- */
-export declare const ms: (value: number) => DesignToken.Values.Duration;
-
-/**
- * Replaces the function of a recipe, in a library made by
- * `extend()`, for every token that computes
- * its value with the recipe. `fn` takes the recipe's arguments and returns a
- * value of its result's type.
- *
- * @example
- * ```ts
- * const contrast = library.extend({}, { recipes: [override(Recipes.darken, darkenMore)] });
- * ```
- *
- * @public
- */
-export declare const override: <A extends unknown[], V>(recipe: Library.Recipe<A, V>, fn: (...args: A) => V) => Library.RecipeOverride;
-
-/**
- * The path of a {@link (Library:namespace).Ref}'s token, the name of each
- * group and of the token: `["colors", "primary"]` for
- * `ref("colors.primary")`.
- *
- * @remarks
- * The library resolves a ref anywhere in a value to its token's value. An
- * add-on that needs the token itself, such as one that writes a CSS custom
- * property for it, keeps the path instead, and finds the token in the
- * library when it needs the value.
- *
- * @example
- * ```ts
- * // An operand of an expression keeps its token's path, so that it's
- * // written as a `var()` and isn't resolved to the token's value.
- * const operand = <T>(arg: number | Library.Ref<number, T>) =>
- *     isRef(arg) ? { token: pathOf(arg).join(".") } : arg;
- * ```
- *
- * @public
- */
-export declare const pathOf: (ref: Library.Ref<unknown, never>) => readonly string[];
-
-/**
- * The converters that {@link toProperties} takes, by type.
- *
- * @public
- */
-export declare type PropertiesConverters = {
-    readonly [type: string]: ((value: any, token: any) => CSSValue) | false;
-};
-
-/**
- * Builds a dimension in pixels.
- *
- * @public
- */
-export declare const px: (value: number) => DesignToken.Values.Dimension;
-
-/**
- * Makes the {@link (Library:namespace).Recipe} of each function of
- * `functions`, named by its key. A recipe takes its function's arguments, any
- * of which may be refs, computed values, or values with them in it, and
- * returns the
- * {@link (Library:namespace).Computed} result. The function is called when
- * the token is read, with the values of the refs, and again when one of the
- * tokens it read changes.
- *
- * @remarks
- * Arguments are evaluated when a function is called, before the library
- * exists, so a function can't be given refs itself: its recipe defers it.
- * The function must be pure, because it's called only when the token's value
- * is resolved again. Its arguments are frozen, as token values are, so its
- * parameters are typed readonly, as in `DesignToken.Values.Readonly.Color`:
- * mutating one throws. A generic function's recipe takes the arguments of its
- * constraint. Recipes are extended by spreading them into a new object, and a
- * recipe's function is replaced in an extended library with {@link override}.
- *
- * @example
- * ```ts
- * // darkenColor(color: DesignToken.Values.Readonly.Color, amount: number)
- * export const Recipes = recipes({ darken: darkenColor, lighten: lightenColor });
- * export const MyRecipes = { ...Recipes, ...recipes({ tint: tintColor }) };
- *
- * hover: { $type: DesignToken.Type.Color, $value: Recipes.darken(ref("colors.primary"), 0.2) }
- * ```
- *
- * @public
- */
-export declare const recipes: <F extends Record<string, (...args: any[]) => unknown>>(functions: F) => Library.Recipes<F>;
-
-/**
- * Makes a {@link (Library:namespace).Ref} to the token at a dotted path. Its
- * type comes from where it's used: the library must have a token at the path
- * whose value has the type expected there.
- *
- * @remarks
- * Where the shape of the library is inferred, as in `Library.create({ ... })`
- * without a type argument, or for a new token in `extend()`, the path can't
- * be checked, so the shape is given as a type argument, or the ref is made
- * with {@link refs}.
- *
- * @example
- * ```ts
- * link: { $type: DesignToken.Type.Color, $value: ref("colors.primary") }
- * ```
- *
- * @public
- */
-export declare const ref: <V, T extends {} = {}>(path: NoInfer<Library.TokenPath<T, V>>) => Library.Ref<V, T>;
-
-/**
- * Makes a {@link (Library:namespace).Ref} to each token of a library of shape
- * `T`, at the token's path: `refs<Theme>().colors.primary` is the same ref as
- * `ref("colors.primary")`. It needs no library, so the refs are made once,
- * before the library's config, and serve every library of the shape.
- *
- * @example
- * ```ts
- * const theme = refs<Theme>();
- * const library = Library.create<Theme>({
- *     colors: {
- *         $type: DesignToken.Type.Color,
- *         primary: { $value: hex("#0000ff") },
- *         link: { $value: theme.colors.primary },
- *     },
- * });
- * ```
- *
- * @public
- */
-export declare const refs: <T extends {}>() => Library.Refs<T>;
-
-/**
- * Builds a dimension in rems.
- *
- * @public
- */
-export declare const rem: (value: number) => DesignToken.Values.Dimension;
-
-/**
- * The key of the phantom type of a ref: what it resolves to, in a library of
- * what shape. It's never set.
- */
-declare const RESOLVES: unique symbol;
-
-/**
- * Builds a duration in seconds.
- *
- * @public
- */
-export declare const s: (value: number) => DesignToken.Values.Duration;
-
-/**
- * A converter for any of the standard types, which is used in place of the one
- * of the library.
- *
- * @public
- */
-export declare type StandardConverters = {
-    [N in keyof DesignToken.ReadonlyValueByType]?: CSSConverter<DesignToken.ReadonlyValueByType[N], Extract<DesignToken.Standard, {
-        $type: N;
-    }>>;
-};
-
-/**
- * Convert a library to CSS custom property declarations.
- *
- * @remarks
- * Libraries with custom token types must provide a converter for each
- * custom type, or `false` to leave tokens of that type out of the CSS.
- * A converter for a standard type is used in place of the one of the library.
- *
- * @public
- */
-export declare function toCSS<T extends {}, R extends {}>(library: Library.Library<T, R>, ...[options]: ToCSSArgs<NoInfer<T>>): string;
-
-/**
- * The trailing arguments of {@link toCSS}: {@link CSSOptions} are
- * required when the library contains custom token types.
- *
- * @public
- */
-export declare type ToCSSArgs<T> = [CustomTokensOf<T>] extends [never] ? [options?: CSSOptions<T>] : [options: CSSOptions<T>];
-
-/**
- * The key of the phantom type that marks a token in
- * {@link (Library:namespace).TokenValues}. It's never set.
- */
-declare const TOKEN: unique symbol;
-
-/**
- * Construct an {@link CSSPropertiesLibrary} from a {@link (Library:namespace).Library}.
- *
- * @remarks
- * Pass the same `converters` given to {@link toCSS} to leave out the tokens it does
- * not write (a custom type whose converter is `false`). They are still in the
- * {@link CSSPropertiesLibrary} type, but missing at runtime.
- *
- * A token whose type has a converter in `converters` has a property for each
- * key of the {@link CSSValues} it returns, so this reads the token's value to
- * call it. Its own property is `var` and `property`, as for any token, and
- * the one for `hover` is at `hover`, so a converter's keys can't be `var` or
- * `property`.
- *
- * @example
- * ```ts
- * const properties = toProperties(library, {
- *     converters: {
- *         states: (value: States) => ({
- *             "": convert("color", value.rest),
- *             hover: convert("color", value.hover),
- *         }),
- *     },
- * });
- * properties.fill.var; // "var(--fill)"
- * properties.fill.hover.var; // "var(--fill-hover)"
- * ```
- *
- * @public
- */
-export declare function toProperties<T extends Library.Library<any>, C extends PropertiesConverters = {}>(library: T, options?: ToPropertiesOptions<C>): CSSPropertiesLibrary<T["tokens"], C>;
-
-/**
- * Options accepted by {@link toProperties}.
- *
- * @public
- */
-export declare interface ToPropertiesOptions<C extends PropertiesConverters = PropertiesConverters> extends CSSPropertiesOptions {
-    /**
-     * The converters given to {@link toCSS}. A token whose custom type is `false`
-     * isn't written by `toCSS`, so it has no custom property and is left out.
-     * A token whose converter returns {@link CSSValues} has a property for
-     * each of its keys.
-     */
-    converters?: C;
-}
-
-export { }