@animus-ui/system 0.1.20 → 0.1.22

package/dist/component-stJhG_A-.d.ts

@@ -0,0 +1,659 @@
+import { i as ClassResolverConfig, t as ClassResolver } from "./createClassResolver-Do1nmvkf.js";
+import { ComponentPropsWithRef, ComponentType, ForwardRefExoticComponent, JSX, ReactNode } from "react";
+import { Globals, ObsoleteProperties, StandardProperties, SvgProperties, VendorProperties } from "csstype";
+//#region src/conditions.d.ts
+/**
+ * Condition alias registry: `_`-prefixed alias keys → at-rule condition
+ * strings, plus the authoring type surface consumers augment.
+ */
+type ConditionKind = 'media' | 'container' | 'supports';
+/**
+ * Augmentable registry of registered condition alias keys. Empty keeps `_`
+ * block keys permissive; publishing either registry validates both.
+ */
+interface Conditions {}
+declare const CONDS_BRAND: unique symbol;
+declare const SELS_BRAND: unique symbol;
+/**
+ * Type-only phantom brand on a built system, carrying the registered
+ * condition (`C`) and selector (`S`) alias keys to the augmentation site.
+ */
+interface RegistryBrand<C extends string = never, S extends string = never> {
+  readonly [CONDS_BRAND]?: C;
+  readonly [SELS_BRAND]?: S;
+}
+type ConditionsOf<Sys> = Sys extends RegistryBrand<infer C, string> ? C : never;
+type SelectorsOf<Sys> = Sys extends RegistryBrand<string, infer S> ? S : never;
+/**
+ * Branded rejection for a `_` block key that no registry owns. Not a bare
+ * `never`: that reports a misleading "not assignable to 'undefined'".
+ */
+interface UnknownConditionAlias<K extends string> {
+  readonly __unknownConditionAlias: K;
+  readonly hint: `"${K}" is not a registered condition or selector alias. Register it with .addConditions() / .addSelectors(), or use a raw "&…" selector or "@media|@container|@supports (…)" key.`;
+}
+interface UnknownAtRule<K extends string> {
+  readonly __unknownAtRule: K;
+  readonly hint: `"${K}" is not a valid at-rule block key. At-rule keys must begin with "@media ", "@container ", or "@supports " followed by a parenthesized/feature tail.`;
+}
+/**
+ * Rejection for an `addConditions()` key the selector registry owns. Never a
+ * bare `never`: in VALUE position it drops both the check and accumulation.
+ */
+interface ReservedBySelectorRegistry<K extends string> {
+  readonly __reservedBySelectorRegistry: K;
+  readonly hint: `"${K}" is already a selector alias — condition and selector alias names must be disjoint. Rename this condition alias, or redefine the selector with .addSelectors().`;
+}
+interface ReservedByConditionRegistry<K extends string> {
+  readonly __reservedByConditionRegistry: K;
+  readonly hint: `"${K}" is already a condition alias — condition and selector alias names must be disjoint. Rename this selector alias, or redefine the condition with .addConditions().`;
+}
+/**
+ * Alias names, or `never` once the union has widened to the whole `_`
+ * pattern — a widened union would reject every legal alias downstream.
+ */
+type NarrowedAliases<U extends string> = `_${string}` extends U ? never : U;
+/**
+ * Prefix + tail only: a deep query grammar hits TS2589. The trailing space
+ * is load-bearing — it rejects prefix typos (`@medi …`) without a grammar.
+ */
+type RawAtRuleKey = `@media ${string}` | `@container ${string}` | `@supports ${string}`;
+/**
+ * No trailing space, unlike `RawAtRuleKey`: a value may open its query
+ * immediately (`@media(width>=40em)`).
+ */
+type AtRuleValue = `@media${string}` | `@container${string}` | `@supports${string}`;
+interface ConditionAlias {
+  /** Full at-rule condition string, e.g. `@media print`. */
+  value: string;
+  /** Sort index for cascade ordering within a layer. */
+  order: number;
+  /** Condition kind, inferred from the at-rule prefix of `value`. */
+  kind: ConditionKind;
+}
+type ConditionAliasMap = Record<string, ConditionAlias>;
+/**
+ * Media-feature aliases only — color-mode aliases are selector-kind. The
+ * reserved order band (300–380) sits below the user band (500+).
+ */
+declare const BUILT_IN_CONDITIONS: ConditionAliasMap;
+//#endregion
+//#region src/keyframes.d.ts
+/**
+ * Frame values take raw CSS or `{scale.key}` token references; a bare scale
+ * key is not resolved. The extractor substitutes refs with the hashed name.
+ */
+type KeyframeFrameMap = Record<string, Record<string, unknown>>;
+interface KeyframeRef<Name extends string> {
+  readonly __brand: 'KeyframeRef';
+  readonly __name: Name;
+  toString(): string;
+  valueOf(): string;
+}
+type Keyframes<Map extends Record<string, KeyframeFrameMap>> = {
+  readonly __brand: 'Keyframes';
+  readonly __frames: { readonly [K in keyof Map & string]: {
+    readonly name: string;
+    readonly frames: Map[K];
+  }; };
+} & { readonly [K in keyof Map & string]: KeyframeRef<K>; };
+//#endregion
+//#region src/selectors.d.ts
+/**
+ * `order` is cascade precedence inside a layer: a later entry overrides an
+ * earlier one at equal specificity.
+ */
+interface SelectorAlias {
+  selector: string;
+  order: number;
+}
+type SelectorAliasMap = Record<string, SelectorAlias>;
+/**
+ * Module augmentation publishes custom aliases as typed `_` keys. Augmenting
+ * either `Selectors` or `Conditions` makes the whole `_` namespace validating.
+ */
+interface Selectors {}
+declare const BUILT_IN_SELECTORS: SelectorAliasMap;
+//#endregion
+//#region src/types/properties.d.ts
+/** CSS Borders 4's `corner-shape`, which the pinned csstype predates. */
+type BordersLevel4Properties = {
+  cornerShape?: Globals | 'bevel' | 'notch' | 'round' | 'scoop' | 'square' | 'squircle' | `superellipse(${string})` | (string & {});
+};
+type AnimusCSSProperties<Overrides = (string & {}) | 0> = StandardProperties<Overrides> & VendorProperties<Overrides> & Pick<ObsoleteProperties<Overrides>, 'WebkitBoxOrient'> & Omit<SvgProperties<Overrides>, keyof StandardProperties> & BordersLevel4Properties;
+type ColorProperties = 'color' | `${string}Color` | 'fill' | 'stroke';
+type ColorGlobals = { [K in Extract<keyof AnimusCSSProperties, ColorProperties>]?: Globals | 'currentColor' | 'transparent' | (string & {}); };
+type SizeProperties = 'left' | 'right' | 'top' | 'bottom' | 'inset' | 'width' | 'height' | `${string}${'Width' | 'Height'}` | 'inlineSize' | 'blockSize' | `${string}${'InlineSize' | 'BlockSize'}` | `inset${'Inline' | 'Block'}${'' | 'Start' | 'End'}`;
+type SizeValues = `${number}${'px' | 'rem' | 'vh' | 'vw' | 'vmax' | 'vmin' | '%'}` | `calc(${any})`;
+type SizeGlobals = { [K in Extract<keyof AnimusCSSProperties, SizeProperties>]?: AnimusCSSProperties[K] | SizeValues | (number & {}); };
+/**
+ * A non-strict `fontSize` takes a number, as the size properties do; a strict
+ * one (`Overrides` of `never`) keeps to its scale.
+ */
+type FontSizeGlobals<Overrides> = {
+  fontSize?: AnimusCSSProperties<Overrides>['fontSize'] | ([Overrides] extends [never] ? never : number & {});
+};
+interface PropertyTypes<Overrides = (string & {}) | 0> extends Omit<AnimusCSSProperties<Overrides>, keyof ColorGlobals | keyof SizeGlobals | 'fontSize'>, ColorGlobals, SizeGlobals, FontSizeGlobals<Overrides> {
+  none?: never;
+  [key: `--${string}`]: (string & {}) | number | undefined;
+}
+//#endregion
+//#region src/theme/flattenScale.d.ts
+/** Every path through T reachable from K, joined by `D`. */
+type FindPath<T, K extends keyof T, D extends string = '.'> = K extends string | number ? T[K] extends Record<string | number, any> ? T[K] extends ArrayLike<any> ? K | `${K}${D}${FindPath<T[K], Exclude<keyof T[K], keyof any[]>, D>}` : K | `${K}${D}${FindPath<T[K], keyof T[K], D>}` : K : never;
+type Path<T, D extends string = '.'> = FindPath<T, keyof T, D> | keyof T;
+type PathValue<T, P extends Path<T, D>, D extends string = '.'> = P extends `${infer K}${D}${infer Rest}` ? K extends keyof T ? Rest extends Path<T[K], D> ? PathValue<T[K], Rest, D> : never : never : P extends keyof T ? T[P] : never;
+/** Only the paths whose value is a string or number, as a union. */
+type PathToLiteral<T, K extends Path<T, D>, D extends string = '.', Base extends string = ''> = PathValue<T, K, D> extends string | number ? K extends string | number ? K extends `${infer BasePath}${D}${Base}` ? BasePath : K : never : never;
+/**
+ * Flat map of the primitive-valued paths only: `{ a: { b: 1 } }` becomes
+ * `{ 'a-b': 1 }` when `D` is `-`.
+ */
+type LiteralPaths<T extends Record<string | number, any>, D extends string = '.', Base extends string = ''> = { [K in Path<T, D> as PathToLiteral<T, K, D, Base>]: PathValue<T, PathToLiteral<T, K, D>, D>; };
+//#endregion
+//#region src/types/shared.d.ts
+interface CSSObject {
+  [key: string]: string | number | CSSObject | undefined;
+}
+//#endregion
+//#region src/types/theme.d.ts
+interface BaseTheme {}
+interface AbstractTheme extends BaseTheme {
+  breakpoints: Record<string, number>;
+  readonly [key: string]: any;
+}
+type ThemeStructuralKey = 'breakpoints' | 'modes' | 'mode' | 'systemPreference' | 'browserColorScheme' | 'modeBases' | '__emitted' | '__declarationScales' | 'manifest' | 'serialize' | 'varRef';
+type TokenScales<T> = Omit<T, ThemeStructuralKey>;
+/**
+ * Consumers augment this interface to constrain CSS values to their theme's
+ * scale keys; unaugmented, values fall back to standard CSS property types.
+ */
+interface Theme extends BaseTheme {}
+type CSSColorValue = `#${string}` | `rgb(${string})` | `rgba(${string})` | `hsl(${string})` | `hsla(${string})` | `oklch(${string})` | `oklab(${string})` | `lch(${string})` | `lab(${string})` | `color-mix(${string})` | `color(${string})` | 'transparent' | 'currentColor' | (string & {});
+/**
+ * Scale names emitted as CSS variables. The `colors` fallback covers augmented
+ * `Theme` interfaces, which carry no `__emitted` tuple.
+ */
+type EmittedScales<T> = T extends {
+  __emitted: [infer E extends string];
+} ? E & keyof TokenScales<T> : 'colors' extends keyof TokenScales<T> ? 'colors' : never;
+type EmittedTokenPaths<T> = keyof LiteralPaths<Pick<TokenScales<T>, EmittedScales<T>>, '.'>;
+type ScaleTokenRef<E extends string> = `${string}{${E}.${string}}${string}`;
+type ColorTokenRef = Theme extends {
+  colors: infer C;
+} ? C extends Record<string, unknown> ? `{colors.${Extract<keyof C, string>}}` | `{colors.${Extract<keyof C, string>}/${number}}` : never : never;
+/** `@property` metadata. A syntax other than `'*'` needs an `initialValue`;
+ *  extraction reports a registration browsers would ignore. */
+interface ContextualVarRegistration {
+  syntax: string;
+  inherits: boolean;
+  initialValue?: string;
+}
+interface SystemPreferenceConfig {
+  light: string;
+  dark: string;
+}
+type BrowserColorSchemeConfig = Record<string, 'light' | 'dark' | 'normal'>;
+/**
+ * Options for `addColorModes`, typed from this call's mode config alone —
+ * threading the mode union through the builder generics risks TS2589.
+ */
+interface ColorModeOptions<Config> {
+  systemPreference?: {
+    light: keyof Config & string;
+    dark: keyof Config & string;
+  };
+  browserColorScheme?: Partial<Record<keyof Config & string, 'light' | 'dark' | 'normal'>>;
+  basedOn?: Partial<Record<keyof Config & string, string>>;
+}
+interface SerializedTheme {
+  scalesJson: string;
+  variableMapJson: string;
+  variableCss: string;
+  contextualVarsJson: string;
+  /**
+   * `{ scale: { kind: 'declarations', members, values: { key: record } } }`,
+   * token references resolved. Absent when the theme has no declaration
+   * scales, so a scalar theme serializes as before.
+   */
+  declarationScalesJson?: string;
+  /**
+   * One record per declared custom property, sorted by name: authored name,
+   * syntax, inherits, initial value, scales, home, whether it is registered,
+   * and whether the contextual-variable method made it. Absent when none.
+   */
+  propertyRecordsJson?: string;
+}
+interface TokenReference {
+  path: string;
+  opacity?: string;
+}
+type TokenDefinition = {
+  kind: 'literal';
+  value: string;
+} | {
+  kind: 'reference';
+  value: string;
+  references: TokenReference[];
+};
+type ModeAliasDefinition = Record<string, Record<string, string>>;
+interface ThemeCssFragment {
+  id: string;
+  kind: 'registrations' | 'base';
+  cssText: string;
+}
+interface ThemeManifest {
+  tokenMap: Record<string, string>;
+  variableMap: Record<string, string>;
+  /**
+   * Mode name → flat key → resolved value; a reference contributes its resolved
+   * value, never a raw `{…}` string. Mode keys and inner keys are sorted.
+   */
+  modes: Record<string, Record<string, string>>;
+  variableCss: string;
+  contextualVars?: Record<string, string[]>;
+  systemPreference?: SystemPreferenceConfig;
+  browserColorScheme?: BrowserColorSchemeConfig;
+  manifestVersion?: 2;
+  tokenDefinitions?: Record<string, TokenDefinition>;
+  emittedScales?: string[];
+  modeAliasDefinitions?: ModeAliasDefinition;
+  registrations?: Record<string, ContextualVarRegistration>;
+  emitterVersion?: number;
+  contractHash?: string;
+  cssFragments?: ThemeCssFragment[];
+}
+//#endregion
+//#region src/types/props.d.ts
+type AbstractProps = ThemeProps<Record<string, unknown>, BaseTheme>;
+type ThemeProps<Props = {}, T extends BaseTheme = BaseTheme> = Props & {
+  theme?: T;
+};
+type ThemeBreakpoints = Theme extends {
+  breakpoints: infer B;
+} ? B : Record<string, number>;
+type BreakpointKeys = keyof ThemeBreakpoints;
+type MediaQueryMap<T> = {
+  _?: T;
+} & (string extends BreakpointKeys ? {
+  [key: string]: T | undefined;
+} : { [K in BreakpointKeys]?: T; });
+type ResponsiveProp<T> = T | MediaQueryMap<T>;
+/**
+ * A component prop's responsive value, where any breakpoint may hold
+ * `undefined`, which the runtime drops. Kept apart from `ResponsiveProp`:
+ * giving that one an `undefined` parameter, even unused, makes TS 5.9
+ * overflow (TS2590) relating a multi-group component's props.
+ */
+type ResponsivePropValue<T> = T | ({
+  _?: T | undefined;
+} & (string extends BreakpointKeys ? {
+  [key: string]: T | undefined;
+} : { [K in BreakpointKeys]?: T | undefined; }));
+//#endregion
+//#region src/types/scales.d.ts
+type MapScale = Record<string | number, string | number>;
+type ArrayScale = readonly (string | number)[];
+//#endregion
+//#region src/types/utils.d.ts
+type Arg<T extends (...args: any) => any> = Parameters<T>[0];
+//#endregion
+//#region src/types/config.d.ts
+interface BaseProperty {
+  property: keyof PropertyTypes;
+  properties?: readonly (keyof PropertyTypes)[];
+}
+interface Prop extends BaseProperty {
+  /** Only a declaration prop has a kind. */
+  kind?: never;
+  scale?: string | MapScale | ArrayScale;
+  variable?: string;
+  negative?: boolean;
+  /**
+   * When false, scale-bound props accept arbitrary strings alongside scale
+   * keys. Defaults to true.
+   */
+  strict?: boolean;
+  currentVar?: string;
+  transform?: (val: string | number, prop?: string, props?: AbstractProps) => string | number;
+}
+/**
+ * Binds a system prop to a declaration scale registered with
+ * `addDeclarationScale`: each key applies its complete record of `members`.
+ * It has no primary property, transform, negative form or raw-value fallback.
+ */
+interface DeclarationProp {
+  kind: 'declarations';
+  scale: DeclarationScaleName;
+  members: readonly (keyof PropertyTypes)[];
+  property?: never;
+  properties?: never;
+  transform?: never;
+  negative?: never;
+  strict?: never;
+  variable?: never;
+  currentVar?: never;
+}
+/** Any system prop definition: a value prop or a declaration prop. */
+type SystemProp = Prop | DeclarationProp;
+type DeclarationScalesOf<T> = T extends {
+  __declarationScales: infer Scales;
+} ? Scales : {};
+/**
+ * The theme's declaration scale names, plus any string: the literal members
+ * keep an authored name literal, so its keys can be read back.
+ */
+type DeclarationScaleName = Extract<keyof DeclarationScalesOf<Theme>, string> | (string & {});
+/** The keys of a declaration prop's scale; any key while the theme is unknown. */
+type DeclarationKey<Config extends DeclarationProp> = Config['scale'] extends keyof DeclarationScalesOf<Theme> ? keyof DeclarationScalesOf<Theme>[Config['scale']] : string | number;
+interface CustomPropConfig extends Prop {
+  transform?: (val: string | number, prop?: string, props?: AbstractProps) => string | number;
+}
+interface AbstractParser {
+  (props: AbstractProps, orderProps?: boolean): CSSObject;
+  propNames: string[];
+  config: Record<string, Prop>;
+}
+type IsEmpty<T> = [] extends T ? true : false | {} extends T ? true : false;
+type StrictOrEmpty<Config extends SystemProp, ScaleT> = Config['strict'] extends false ? true : IsEmpty<ScaleT>;
+type NegateKeys<T> = T extends number ? T extends 0 ? never : `-${T}` extends `${infer N extends number}` ? N : never : never;
+type PropertyValues<Property extends SystemProp, IncludeGlobals = false> = Exclude<PropertyTypes<IncludeGlobals extends true ? (string & {}) | 0 : never>[Property['property'] & string], IncludeGlobals extends true ? never : object | any[]>;
+type NegativeOf<Config extends SystemProp, Keys> = Config['negative'] extends true ? NegateKeys<Extract<Keys, number>> : never;
+/**
+ * What a strict scale admits beside its keys and keywords, as strict
+ * extraction and the runtime do: the string zero on a property that takes a
+ * length, and a reference to one of the scale's own tokens. A non-strict scale
+ * already admits both through its raw values. The numeric zero waits: adding
+ * a number to every length prop overflows the union TS builds when checking
+ * keyframe frames against a large prop registry (TS2590).
+ */
+type StrictAdmissions<Config extends SystemProp, Strict, ScaleName, Keys> = Strict extends true ? never : (0 extends PropertyValues<Config, true> ? '0' : never) | (ScaleName extends string ? `{${ScaleName}.${Extract<Keys, string | number>}}` : never);
+type ScaleValue<Config extends SystemProp, T extends BaseTheme> = Config['scale'] extends keyof TokenScales<T> ? keyof TokenScales<T>[Config['scale']] | NegativeOf<Config, keyof TokenScales<T>[Config['scale']]> | PropertyValues<Config, StrictOrEmpty<Config, TokenScales<T>[Config['scale']]>> | StrictAdmissions<Config, StrictOrEmpty<Config, TokenScales<T>[Config['scale']]>, Config['scale'], keyof TokenScales<T>[Config['scale']]> : Config['scale'] extends MapScale ? keyof Config['scale'] | NegativeOf<Config, keyof Config['scale']> | PropertyValues<Config, StrictOrEmpty<Config, Config['scale']>> | StrictAdmissions<Config, StrictOrEmpty<Config, Config['scale']>, never, never> : Config['scale'] extends ArrayScale ? Config['scale'][number] | PropertyValues<Config, StrictOrEmpty<Config, Config['scale']>> | StrictAdmissions<Config, StrictOrEmpty<Config, Config['scale']>, never, never> : PropertyValues<Config, true>;
+type Scale<Config extends SystemProp, T extends BaseTheme> = [Config] extends [DeclarationProp] ? ResponsiveProp<DeclarationKey<Extract<Config, DeclarationProp>>> : ResponsiveProp<ScaleValue<Config, T>>;
+type ParserProps<Config extends Record<string, SystemProp>, T extends BaseTheme> = ThemeProps<{ [P in keyof Config]?: Scale<Config[P], T>; }, T>;
+interface Parser<Config extends Record<string, SystemProp>, T extends BaseTheme> {
+  (props: ParserProps<Config, T>, orderProps?: boolean): CSSObject;
+  propNames: Extract<keyof Config, string>[];
+  config: Config;
+}
+type SystemProps<P extends AbstractParser, SafeProps = Omit<Arg<P>, 'theme'>> = { [K in keyof SafeProps]: SafeProps[K]; };
+type ColorOpacityRef<Config extends SystemProp> = Config['scale'] extends 'colors' ? 'colors' extends keyof TokenScales<Theme> ? `{colors.${keyof TokenScales<Theme>[Config['scale'] & keyof TokenScales<Theme>] & string}/${number}}` : never : never;
+/**
+ * The six container-query units, admitted on strict scale props ('2vw' stays
+ * rejected). The union stays flat — cross-products hit TS2589.
+ */
+type ContainerUnitValue = `${number}cqw` | `${number}cqi` | `${number}cqh` | `${number}cqb` | `${number}cqmin` | `${number}cqmax`;
+type ThemedScaleValue<Config extends SystemProp> = Config['scale'] extends keyof TokenScales<Theme> ? keyof TokenScales<Theme>[Config['scale']] | NegativeOf<Config, keyof TokenScales<Theme>[Config['scale']]> | PropertyValues<Config, StrictOrEmpty<Config, TokenScales<Theme>[Config['scale']]>> | StrictAdmissions<Config, StrictOrEmpty<Config, TokenScales<Theme>[Config['scale']]>, Config['scale'], keyof TokenScales<Theme>[Config['scale']]> | ColorOpacityRef<Config> | ContainerUnitValue : Config['scale'] extends MapScale ? keyof Config['scale'] | NegativeOf<Config, keyof Config['scale']> | PropertyValues<Config, StrictOrEmpty<Config, Config['scale']>> | StrictAdmissions<Config, StrictOrEmpty<Config, Config['scale']>, never, never> | ContainerUnitValue : Config['scale'] extends ArrayScale ? Config['scale'][number] | PropertyValues<Config, StrictOrEmpty<Config, Config['scale']>> | StrictAdmissions<Config, StrictOrEmpty<Config, Config['scale']>, never, never> : PropertyValues<Config, true>;
+type ThemedScale<Config extends SystemProp> = [Config] extends [DeclarationProp] ? ResponsiveProp<DeclarationKey<Extract<Config, DeclarationProp>>> : ResponsiveProp<ThemedScaleValue<Config>>;
+/** `ThemedScale` as a component prop takes it: see `ResponsivePropValue`. */
+type ThemedPropValue<Config extends SystemProp> = [Config] extends [DeclarationProp] ? ResponsivePropValue<DeclarationKey<Extract<Config, DeclarationProp>>> : ResponsivePropValue<ThemedScaleValue<Config>>;
+type RawSelectorKey = `${string}&${string}`;
+type PublishedAliasKeys = Extract<keyof Conditions | keyof Selectors, `_${string}`>;
+type KnownUnderscoreKey = [PublishedAliasKeys] extends [never] ? `_${string}` : BuiltInSelectorAlias | BuiltInConditionAlias | PublishedAliasKeys;
+/** A keyword with `!important`, which CSS accepts after any declared value,
+ *  or the shorthand `!` that means the same. */
+type Important<Value> = Value extends string ? `${Value} !important` | `${Value}!` : never;
+type PassThroughProp<K extends keyof PropertyTypes> = K extends 'animationName' ? ResponsiveProp<KeyframeRef<string> | PropertyTypes[K]> : ResponsiveProp<PropertyTypes[K] | Important<PropertyTypes<never>[K]>>;
+type UnderscoreBlockMembers<Config extends Record<string, SystemProp>> = { [K in KnownUnderscoreKey]?: ThemedBlockBody<Config>; };
+/**
+ * Must stay a FIXED type: an arm referencing the outer inferred `Props` is
+ * reverse-mapped away at `.styles()` and stops checking nested values.
+ */
+type ThemedBlockBody<Config extends Record<string, SystemProp>> = { [K in Exclude<keyof PropertyTypes, keyof Config>]?: PassThroughProp<K>; } & { [P in keyof Config]?: ThemedScale<Config[P]>; } & { [K in RawSelectorKey | RawAtRuleKey]?: ThemedBlockBody<Config>; } & UnderscoreBlockMembers<Config>;
+type ThemedCSSProps<Props, Config extends Record<string, SystemProp>> = { [K in keyof Props]?: K extends keyof Config ? ThemedScale<Config[K]> : K extends RawSelectorKey ? ThemedBlockBody<Config> : K extends RawAtRuleKey ? ThemedBlockBody<Config> : K extends KnownUnderscoreKey ? ThemedBlockBody<Config> : K extends keyof PropertyTypes ? PassThroughProp<K> : K extends `_${string}` ? UnknownConditionAlias<K & string> : K extends `@${string}` ? UnknownAtRule<K & string> : Omit<PropertyTypes, keyof Config> & { [P in keyof Config]?: ThemedScale<Config[P]>; }; };
+type ThemedCSSPropMap<Props, Config extends Record<string, SystemProp>> = { [K in keyof Props]?: ThemedCSSProps<Props[K], Config>; };
+interface VariantConfig {
+  prop?: string;
+  defaultVariant?: string;
+  base?: CSSProps<AbstractProps, SystemProps<AbstractParser>>;
+  variants: CSSPropMap<AbstractProps, SystemProps<AbstractParser>>;
+}
+interface CompoundEntry {
+  condition: Record<string, string>;
+  styles: CSSProps<AbstractProps, SystemProps<AbstractParser>>;
+}
+type CSSPropMap<Props, System> = { [K in keyof Props]?: CSSProps<Props[K], System>; };
+type CSSProps<Props, System> = { [K in keyof Props]?: K extends keyof System ? System[K] : K extends keyof PropertyTypes ? PropertyTypes[K] : Omit<PropertyTypes, keyof System> & Omit<System, 'theme'>; };
+type BuiltInSelectorAlias = '_link' | '_visited' | '_hover' | '_focus' | '_focusVisible' | '_focusWithin' | '_active' | '_target' | '_disabled' | '_checked' | '_invalid' | '_required' | '_readOnly' | '_expanded' | '_selected' | '_pressed' | '_before' | '_after' | '_placeholder' | '_selection' | '_first' | '_last' | '_even' | '_odd' | '_empty';
+/**
+ * Built-in media-condition aliases. A static union, never members of the
+ * augmentable `Conditions`: membership would make the `_` namespace validating
+ * for every consumer. Every alias needs a matching entry in
+ * `BUILT_IN_CONDITIONS` in conditions.ts, and only type tests catch that drift.
+ */
+type BuiltInConditionAlias = '_motionReduce' | '_motionSafe' | '_print' | '_portrait' | '_landscape' | '_moreContrast' | '_lessContrast' | '_osDark' | '_osLight';
+type SelectorAliasProps<GroupPropValues> = { [K in BuiltInSelectorAlias | Extract<keyof Selectors, `_${string}`>]?: Partial<GroupPropValues> | undefined; };
+//#endregion
+//#region src/types/styling-names.d.ts
+/** `T`'s declared keys, without a string index signature. */
+type KnownKeys$1<T> = keyof { [K in keyof T as string extends K ? never : K]: T[K]; };
+/** The variant and state props a component declared. */
+type StylingNames<Variants, States> = Extract<KnownKeys$1<Variants> | KnownKeys$1<States>, string>;
+/** The system props one `.system()` key admits: a group's members, or the prop. */
+type PickedProps<GroupRegistry, Key> = Key extends keyof GroupRegistry ? GroupRegistry[Key] extends readonly (infer Member)[] ? Extract<Member, string> : never : Extract<Key, string>;
+/** The system props a component admitted. */
+type AdmittedNames<GroupRegistry, ActiveGroups> = PickedProps<GroupRegistry, KnownKeys$1<ActiveGroups>>;
+/**
+ * A `.system()` config. Each key is `true`, unless it admits a prop that a
+ * variant or state already names: one value would then drive both.
+ */
+type SystemPicks<GroupRegistry, Picked extends PropertyKey, Names extends string> = { [K in Picked]: [Extract<PickedProps<GroupRegistry, K>, Names>] extends [never] ? true : K extends keyof GroupRegistry ? `"${K & string}" admits "${Extract<PickedProps<GroupRegistry, K>, Names>}", already a variant or state prop` : `"${K & string}" is already a variant or state prop`; };
+/** A variant prop name, unless a system prop of that name is admitted. */
+type UnadmittedName<Name extends string, Admitted> = Name extends Admitted ? `"${Name}" is already an admitted system prop` : Name;
+/** Rejects each state named after an admitted system prop. */
+type UnadmittedStates<Props, Admitted> = { [K in Extract<keyof Props, Admitted>]: `"${K & string}" is already an admitted system prop`; };
+//#endregion
+//#region src/AnimusExtended.d.ts
+/** `T`'s declared keys, without a string index signature. */
+type KnownKeys<T> = keyof { [K in keyof T as string extends K ? never : K]: T[K]; };
+/**
+ * The options an extension inherits on the axis `PropKey`. Redeclaring the
+ * axis merges its options at runtime, so a default may name any of them. An
+ * axis the parent never declared resolves through the extension's string
+ * index to a table with no declared options.
+ */
+type InheritedOptions<Variants, PropKey extends string> = Variants[PropKey & keyof Variants] extends {
+  variants: infer Options;
+} ? Extract<KnownKeys<Options>, string> : never;
+/**
+ * The inherited custom props without those `Own` redeclares, then `Own`.
+ * Key remapping keeps the known keys beside the extension's index signature,
+ * which `Omit` would collapse.
+ */
+type Redeclared<Inherited, Own> = { [K in keyof Inherited as K extends keyof Own ? never : K]: Inherited[K]; } & Own;
+declare class AnimusExtendedWithAll<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>, CustomProps extends Record<string, SystemProp>> {
+  propRegistry: PropRegistry;
+  groupRegistry: GroupRegistry;
+  baseStyles: BaseStyles;
+  statesConfig: States;
+  variants: Variants;
+  activeGroups: ActiveGroups;
+  custom: CustomProps;
+  compounds: CompoundEntry[];
+  constructor(props: PropRegistry, groups: GroupRegistry, base: BaseStyles, variants: Variants, states: States, activeGroups: ActiveGroups, custom: CustomProps, compounds?: CompoundEntry[]);
+  protected extend(): AnimusExtended<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+  asElement<El extends keyof JSX.IntrinsicElements>(component: El): AnimusComponent<El, PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+  asComponent<C extends ComponentType<any>>(AsComponent: C): AnimusWrappedComponent<C, PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+  asClass<This extends {
+    _buildComponentConfig(): ClassResolverConfig;
+  }>(this: This): ClassResolver<BuilderClassProps<This>>;
+  _buildComponentConfig(): ClassResolverConfig;
+}
+declare class AnimusExtendedWithSystem<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>, CustomProps extends Record<string, SystemProp>> extends AnimusExtendedWithAll<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps> {
+  props<NewCustomProps extends Record<string, CustomPropConfig | DeclarationProp>>(config: NewCustomProps): AnimusExtendedWithAll<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, Redeclared<CustomProps, NewCustomProps>>;
+}
+declare class AnimusExtendedWithStates<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>, CustomProps extends Record<string, SystemProp>> extends AnimusExtendedWithSystem<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps> {
+  system<PickedKeys extends keyof GroupRegistry | Extract<keyof PropRegistry, string>>(config: SystemPicks<GroupRegistry, PickedKeys, StylingNames<Variants, States>>): AnimusExtendedWithSystem<PropRegistry, GroupRegistry, BaseStyles, Variants, States, Record<PickedKeys, true> & ActiveGroups, CustomProps>;
+}
+declare class AnimusExtendedWithCompounds<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>, CustomProps extends Record<string, SystemProp>> extends AnimusExtendedWithStates<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps> {
+  compound<Props extends AbstractProps>(condition: { [K in keyof Variants]?: keyof Variants[K]['variants'] | ReadonlyArray<keyof Variants[K]['variants']>; }, styles: ThemedCSSProps<Props, PropRegistry>): AnimusExtendedWithCompounds<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+  states<Props extends AbstractProps>(config: ThemedCSSPropMap<Props, PropRegistry> & UnadmittedStates<Props, AdmittedNames<GroupRegistry, ActiveGroups>>): AnimusExtendedWithStates<PropRegistry, GroupRegistry, BaseStyles, Variants, ThemedCSSPropMap<Props, PropRegistry> & UnadmittedStates<Props, AdmittedNames<GroupRegistry, ActiveGroups>> & States, ActiveGroups, CustomProps>;
+}
+declare class AnimusExtendedWithVariants<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>, CustomProps extends Record<string, SystemProp>> extends AnimusExtendedWithCompounds<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps> {
+  compound<Props extends AbstractProps>(condition: { [K in keyof Variants]?: keyof Variants[K]['variants'] | ReadonlyArray<keyof Variants[K]['variants']>; }, styles: ThemedCSSProps<Props, PropRegistry>): AnimusExtendedWithCompounds<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+  variant<Keys extends keyof Props, Base extends AbstractProps, Props extends Record<Keys, AbstractProps>, PropKey extends Readonly<string> = 'variant'>(options: {
+    prop?: UnadmittedName<PropKey, AdmittedNames<GroupRegistry, ActiveGroups>>;
+    defaultVariant?: Extract<keyof Props, string> | InheritedOptions<Variants, PropKey>;
+    base?: ThemedCSSProps<Base, PropRegistry>;
+    variants: ThemedCSSPropMap<Props, PropRegistry>;
+  }): AnimusExtendedWithVariants<PropRegistry, GroupRegistry, BaseStyles, Variants & Record<PropKey, {
+    prop?: UnadmittedName<PropKey, AdmittedNames<GroupRegistry, ActiveGroups>>;
+    defaultVariant?: Extract<keyof Props, string> | InheritedOptions<Variants, PropKey> | undefined;
+    base?: ThemedCSSProps<Base, PropRegistry>;
+    variants: ThemedCSSPropMap<Props, PropRegistry>;
+  }>, States, ActiveGroups, CustomProps>;
+}
+declare class AnimusExtendedWithBase<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>, CustomProps extends Record<string, SystemProp>> extends AnimusExtendedWithVariants<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps> {
+  variant<Keys extends keyof Props, Base extends AbstractProps, Props extends Record<Keys, AbstractProps>, PropKey extends Readonly<string> = 'variant'>(options: {
+    prop?: UnadmittedName<PropKey, AdmittedNames<GroupRegistry, ActiveGroups>>;
+    defaultVariant?: Extract<keyof Props, string> | InheritedOptions<Variants, PropKey>;
+    base?: ThemedCSSProps<Base, PropRegistry>;
+    variants: ThemedCSSPropMap<Props, PropRegistry>;
+  }): AnimusExtendedWithVariants<PropRegistry, GroupRegistry, BaseStyles, Variants & Record<PropKey, {
+    prop?: UnadmittedName<PropKey, AdmittedNames<GroupRegistry, ActiveGroups>>;
+    defaultVariant?: Extract<keyof Props, string> | InheritedOptions<Variants, PropKey> | undefined;
+    base?: ThemedCSSProps<Base, PropRegistry>;
+    variants: ThemedCSSPropMap<Props, PropRegistry>;
+  }>, States, ActiveGroups, CustomProps>;
+}
+declare class AnimusExtended<PropRegistry extends Record<string, SystemProp>, GroupRegistry extends Record<string, (keyof PropRegistry)[]>, BaseStyles extends CSSProps<AbstractProps, SystemProps<AbstractParser>>, Variants extends Record<string, VariantConfig>, States extends CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, ActiveGroups extends Record<string, true>, CustomProps extends Record<string, SystemProp>> extends AnimusExtendedWithBase<PropRegistry, GroupRegistry, BaseStyles, Variants, States, ActiveGroups, CustomProps> {
+  styles<Props extends AbstractProps>(config: ThemedCSSProps<Props, PropRegistry>): AnimusExtendedWithBase<PropRegistry, GroupRegistry, ThemedCSSProps<Props, PropRegistry> & BaseStyles, Variants, States, ActiveGroups, CustomProps>;
+}
+//#endregion
+//#region src/types/component.d.ts
+declare const ConsumerProps: unique symbol;
+declare const VariantConfigBrand: unique symbol;
+/**
+ * Structural constraint for compose() slots. `any` as P avoids expanding the
+ * full AnimusComponent intersection, which hits TS2590 on large registries.
+ */
+type AnyBrandedComponent = ForwardRefExoticComponent<any> & {
+  readonly [ConsumerProps]: unknown;
+  readonly [VariantConfigBrand]: unknown;
+  extend: () => unknown;
+};
+type ExtendFn<PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, BS, V, S, AG, CP> = {
+  extend: () => AnimusExtended<PR, GR, BS & CSSProps<AbstractProps, SystemProps<AbstractParser>>, V & Record<string, VariantConfig>, S & CSSPropMap<AbstractProps, SystemProps<AbstractParser>>, AG & Record<string, true>, CP & Record<string, SystemProp>>;
+};
+type ActiveGroupPropNames<PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, AG> = GR[Extract<keyof StripIndex<AG>, keyof GR>][number] | Extract<keyof StripIndex<AG>, keyof PR>;
+type GroupProps<PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, AG> = { [K in ActiveGroupPropNames<PR, GR, AG> as K extends string ? K : never]?: ThemedPropValue<PR[K & keyof PR]> | undefined; };
+type CustomPropValues<CP extends Record<string, SystemProp>> = { [K in keyof StripIndex<CP>]?: ThemedPropValue<StripIndex<CP>[K & keyof StripIndex<CP>]> | undefined; };
+type StripIndex<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K]; };
+/**
+ * Each axis's options, read from its `variants` table alone. A declaration
+ * build without `exactOptionalPropertyTypes` prints a config's optional fields
+ * as `?: X | undefined`, so testing the whole config against `VariantConfig`
+ * fails in a consumer that sets it, and the axis would widen to `string`.
+ */
+type VariantProps<V> = { [K in keyof StripIndex<V>]?: StripIndex<V>[K] extends {
+  variants: infer Options;
+} ? keyof Options | undefined : string | undefined; };
+type StateProps<S> = { [K in keyof StripIndex<S>]?: boolean | undefined; };
+/**
+ * Keys Animus consumes; the runtime strips them before DOM forwarding.
+ * Unioned per source — `keyof` of the intersection hits TS2590 on emit.
+ */
+type AnimusManagedKeys<PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, V, S, AG, CP extends Record<string, SystemProp>> = ActiveGroupPropNames<PR, GR, AG> | keyof VariantProps<V> | keyof StateProps<S> | keyof StripIndex<CP> | 'as' | 'asChild' | 'className' | 'children';
+/**
+ * Named alias so group props and selector-alias values share one mapped type;
+ * inlining it re-derives the type instead of hitting the structural cache.
+ */
+type ResolvedGroupProps<PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, AG> = GroupProps<PR, GR, AG>;
+/** What `as` names on a string terminal: an element tag or a component. */
+type AsTarget = keyof JSX.IntrinsicElements | ComponentType<any>;
+/** Everything the builder admitted, whichever element renders. */
+type AnimusOwnProps<PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, V, S, AG, CP extends Record<string, SystemProp>> = ResolvedGroupProps<PR, GR, AG> & VariantProps<V> & StateProps<S> & CustomPropValues<CP> & SelectorAliasProps<ResolvedGroupProps<PR, GR, AG>> & {
+  asChild?: boolean | undefined;
+  className?: string | undefined;
+  children?: ReactNode;
+};
+/** A string terminal rendered as `E`: E's native props and ref, then Animus's. */
+type AnimusNativeProps<E extends AsTarget, PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, V, S, AG, CP extends Record<string, SystemProp>> = Omit<ComponentPropsWithRef<E>, AnimusManagedKeys<PR, GR, V, S, AG, CP>> & AnimusOwnProps<PR, GR, V, S, AG, CP>;
+/**
+ * The default element's props with `as` open to any target, as compose()
+ * reads a slot.
+ */
+type AnimusConsumerProps<El extends keyof JSX.IntrinsicElements, PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, V, S, AG, CP extends Record<string, SystemProp>> = AnimusNativeProps<El, PR, GR, V, S, AG, CP> & {
+  as?: AsTarget | undefined;
+};
+/**
+ * The element `As` selects, or the default element when `As` stays at its
+ * constraint.
+ */
+type ElementFor<As extends AsTarget, El extends keyof JSX.IntrinsicElements> = [AsTarget] extends [As] ? El : As;
+/**
+ * The default element's signature comes first; without it the builder classes
+ * hit TS2589 or check in seconds instead of under one. The polymorphic
+ * signature comes last: `ComponentProps` and `createElement` read the last
+ * signature, and a rejected JSX call reports its error, naming the prop the
+ * selected element or component lacks.
+ */
+type AnimusComponent<El extends keyof JSX.IntrinsicElements, PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, BS, V, S, AG, CP extends Record<string, SystemProp>> = ForwardRefExoticComponent<AnimusNativeProps<El, PR, GR, V, S, AG, CP> & {
+  as?: El | undefined;
+}> & (<As extends AsTarget>(props: AnimusNativeProps<ElementFor<As, El>, PR, GR, V, S, AG, CP> & {
+  as?: As | undefined;
+}) => ReactNode) & ExtendFn<PR, GR, BS, V, S, AG, CP> & {
+  readonly [ConsumerProps]: AnimusConsumerProps<El, PR, GR, V, S, AG, CP>;
+  readonly [VariantConfigBrand]: V;
+  readonly variantDefaults: Readonly<Record<string, string>>;
+};
+/** `Omit` per union member, so a discriminated-union target keeps each arm. */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * The wrapped component's own props, with its ref, then exactly what the
+ * builder admitted: the active groups' props, variants, states and custom
+ * props. Managed keys are removed from the wrapped component's props first —
+ * intersecting a variant union with its own type for a key collapses to never.
+ * `as` and `asChild` are the target's own, since the runtime hands them to it:
+ * a target without them does not offer them.
+ */
+type AnimusWrappedConsumerProps<C extends ComponentType<any>, PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, V, S, AG, CP extends Record<string, SystemProp>> = DistributiveOmit<ComponentPropsWithRef<C>, Exclude<AnimusManagedKeys<PR, GR, V, S, AG, CP>, 'as' | 'asChild'>> & ResolvedGroupProps<PR, GR, AG> & VariantProps<V> & StateProps<S> & CustomPropValues<CP> & SelectorAliasProps<ResolvedGroupProps<PR, GR, AG>> & {
+  className?: string | undefined;
+  children?: ReactNode;
+};
+type AnimusWrappedComponent<C extends ComponentType<any>, PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, BS, V, S, AG, CP extends Record<string, SystemProp>> = ForwardRefExoticComponent<AnimusWrappedConsumerProps<C, PR, GR, V, S, AG, CP>> & ExtendFn<PR, GR, BS, V, S, AG, CP> & {
+  readonly [ConsumerProps]: AnimusWrappedConsumerProps<C, PR, GR, V, S, AG, CP>;
+  readonly [VariantConfigBrand]: V;
+  readonly variantDefaults: Readonly<Record<string, string>>;
+};
+type StripStringIndex<T> = { [K in keyof T as string extends K ? never : K]: T[K]; };
+type ExtractVariantsConfig<C> = C extends {
+  readonly [VariantConfigBrand]: infer V;
+} ? StripStringIndex<V> : C extends {
+  extend: () => {
+    variants: infer V;
+  };
+} ? StripStringIndex<V> : {};
+type VariantPropsOf<C> = VariantProps<ExtractVariantsConfig<C>>;
+type RootSlot<Slots extends Record<string, unknown>> = 'Root' extends keyof Slots ? Slots['Root'] : never;
+type RootVariantKeys<Slots extends Record<string, unknown>> = keyof VariantPropsOf<RootSlot<Slots>> & string;
+type SharedConfig<Slots extends Record<string, unknown>> = { [K in RootVariantKeys<Slots>]?: true; };
+type SealedProps<C> = C extends {
+  readonly [ConsumerProps]: infer P;
+} ? Omit<P, 'extend'> & {
+  className?: string | undefined;
+  children?: ReactNode;
+} : C extends ForwardRefExoticComponent<infer P> ? Omit<P, 'extend'> & {
+  className?: string | undefined;
+  children?: ReactNode;
+} : never;
+type ComposedFamily<Slots extends Record<string, unknown>> = { [K in keyof Slots]: ForwardRefExoticComponent<SealedProps<Slots[K]>>; };
+/** An `asClass()` resolver's input: exactly the props the builder admitted. */
+type AnimusClassProps<PR extends Record<string, SystemProp>, GR extends Record<string, (keyof PR)[]>, V, S, AG, CP extends Record<string, SystemProp>> = ResolvedGroupProps<PR, GR, AG> & VariantProps<V> & StateProps<S> & CustomPropValues<CP> & SelectorAliasProps<ResolvedGroupProps<PR, GR, AG>>;
+/**
+ * The `asClass()` input of the builder `B`, read from the registries its
+ * public fields carry. Resolved from the receiver at the call, so the
+ * builder classes' own type parameters never carry it.
+ */
+type BuilderClassProps<B> = B extends {
+  propRegistry: infer PR extends Record<string, SystemProp>;
+} ? B extends {
+  groupRegistry: infer GR extends Record<string, (keyof PR)[]>;
+  variants: infer V;
+  statesConfig: infer S;
+  activeGroups: infer AG;
+  custom: infer CP extends Record<string, SystemProp>;
+} ? AnimusClassProps<PR, GR, V, S, AG, CP> : never : never;
+//#endregion
+export { SerializedTheme as $, SystemProps as A, ReservedByConditionRegistry as At, ResponsiveProp as B, ParserProps as C, ConditionAliasMap as Ct, ScaleValue as D, NarrowedAliases as Dt, Scale as E, ConditionsOf as Et, VariantConfig as F, CSSColorValue as G, AbstractTheme as H, ArrayScale as I, ContextualVarRegistration as J, ColorModeOptions as K, MapScale as L, ThemedCSSProps as M, SelectorsOf as Mt, ThemedScale as N, UnknownAtRule as Nt, SelectorAliasProps as O, RawAtRuleKey as Ot, ThemedScaleValue as P, UnknownConditionAlias as Pt, ScaleTokenRef as Q, AbstractProps as R, Parser as S, ConditionAlias as St, PropertyValues as T, Conditions as Tt, BaseTheme as U, ThemeProps as V, BrowserColorSchemeConfig as W, EmittedTokenPaths as X, EmittedScales as Y, ModeAliasDefinition as Z, CSSProps as _, KeyframeFrameMap as _t, BuilderClassProps as a, TokenDefinition as at, DeclarationKey as b, AtRuleValue as bt, VariantPropsOf as c, FindPath as ct, StylingNames as d, PathToLiteral as dt, SystemPreferenceConfig as et, SystemPicks as f, PathValue as ft, CSSPropMap as g, Selectors as gt, BuiltInSelectorAlias as h, SelectorAliasMap as ht, AnyBrandedComponent as i, ThemeStructuralKey as it, ThemedCSSPropMap as j, ReservedBySelectorRegistry as jt, SystemProp as k, RegistryBrand as kt, AnimusExtended as l, LiteralPaths as lt, BuiltInConditionAlias as m, SelectorAlias as mt, AnimusComponent as n, ThemeCssFragment as nt, ComposedFamily as o, TokenScales as ot, AbstractParser as p, BUILT_IN_SELECTORS as pt, ColorTokenRef as q, AnimusWrappedComponent as r, ThemeManifest as rt, SharedConfig as s, CSSObject as st, AnimusClassProps as t, Theme as tt, AnimusExtendedWithAll as u, Path as ut, CompoundEntry as v, KeyframeRef as vt, Prop as w, ConditionKind as wt, DeclarationProp as x, BUILT_IN_CONDITIONS as xt, CustomPropConfig as y, Keyframes as yt, MediaQueryMap as z };
+//# sourceMappingURL=component-stJhG_A-.d.ts.map