
//#region ../automated-config/dist/types/StateAxis.d.ts
//#region src/types/StateAxis.d.ts
/**
 * Atomic-state taxonomy.
 *
 * Every interactive component reacts to a fixed set of "atomic" states, each
 * belonging to one axis:
 *
 * - `interactive` — pointer/keyboard focus signals. At runtime at most one of
 *   these is meaningfully "active" at a time on a given element (you can't
 *   simultaneously hover and press distinctly enough to style separately, etc.).
 *
 * - `modifier` — semantic flags that can stack independently of each other and
 *   of the interactive state. An input can be `invalid` AND `readonly` at the
 *   same time, optionally also `hover`ed.
 *
 * Compound states (`'invalid&hover'`, `'invalid&readonly&hover'`, etc.) are
 * built by listing 0..N modifiers followed by 0..1 interactive. The
 * `canonicalizeStateKey` helper enforces this ordering so that, e.g.,
 * `['hover', 'invalid']` and `['invalid', 'hover']` resolve to the same key.
 */
/**
 * Interactive atomics:
 *
 * - `hover`/`pressed` for pointer interaction.
 * - `focus-within` for containers that wrap a focusable child (e.g. an input
 *   wrapper).
 * - `focus-visible` for keyboard-only focus rings on focusable elements.
 */
declare const INTERACTIVE_ATOMICS: readonly ["hover", "pressed", "focus-within", "focus-visible"];
declare const MODIFIER_ATOMICS: readonly ["invalid", "readonly", "placeholder-shown", "autofill", "visited"];
type InteractiveAtomic = (typeof INTERACTIVE_ATOMICS)[number];
type ModifierAtomic = (typeof MODIFIER_ATOMICS)[number];
type AtomicState = InteractiveAtomic | ModifierAtomic;
declare function isInteractiveAtomic(state: string): state is InteractiveAtomic;
declare function isModifierAtomic(state: string): state is ModifierAtomic;
declare function isAtomicState(state: string): state is AtomicState;
/**
 * Maximum number of modifiers that may appear in a single compound state.
 * The resolver enumerates compounds up to `M^MAX_MODIFIERS_PER_COMPOUND × I`
 * (with the interactive slot optional), the docs-class enumeration matches,
 * and the StateBuilder picker prevents users from selecting more than this
 * many modifier checkboxes. Keeping all three in lock-step means there's
 * exactly one compound depth supported end-to-end.
 */
declare const MAX_MODIFIERS_PER_COMPOUND = 3;
/**
 * Global emission priority for the atomic taxonomy.
 *
 * Every atom selector contributes a uniform (0,1,0) of specificity (see
 * `pseudoStateSelectors`), so a 2-atom compound at (0,3,0) strictly beats a
 * 1-atom rule at (0,2,0) — cross-rank cascade is encoded in class-count
 * specificity. Within a rank (e.g. two atoms simultaneously matching the
 * same element) source order arbitrates: the resolver sorts a layer's
 * `atomicStates` by index in this array, then emits in that order — meaning
 * **later in the array = emits later = wins when multiple atoms match the
 * same element**.
 *
 * The ordering is weakest → strongest. To bump an atom's priority, move it
 * later in this array. Compound-state emission order is derived from this
 * priority too (subset enumeration follows the modifier ordering here), so
 * compound winners follow the same intuition.
 *
 * Legacy atoms (`focused`, `focused-keyboard`, `disabled`) are not in this
 * list because they aren't part of `AtomicState`; their emission order is
 * whatever a config's per-property `pseudoStates` array specifies.
 */
//#endregion
export { type AtomicState, INTERACTIVE_ATOMICS, type InteractiveAtomic, MAX_MODIFIERS_PER_COMPOUND, MODIFIER_ATOMICS, type ModifierAtomic, isAtomicState, isInteractiveAtomic, isModifierAtomic };