praxis-kit 1.1.0

package/dist/merge-refs-CfBqh1UO.d.ts

@@ -0,0 +1,374 @@
+import { RequireAtLeastOne, Simplify, ReadonlyDeep, NonEmptyTuple } from 'type-fest';
+import { ComponentType, PropsWithChildren, ReactElement, JSX, Ref, ReactNode } from 'react';
+
+type AnyRecord = Record<string, unknown>;
+
+type IntrinsicTag = keyof HTMLElementTagNameMap;
+
+type ElementType = IntrinsicTag | (string & {});
+
+declare const KNOWN_ARIA_ROLES: readonly ["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"];
+type KnownAriaRole = (typeof KNOWN_ARIA_ROLES)[number];
+
+type AriaRole = KnownAriaRole | (string & {});
+
+type ClassName = string | string[];
+
+type EmptyRecord = Record<never, never>;
+
+type IntrinsicProps = AnyRecord & {
+    role?: AriaRole;
+};
+
+type NonEmptyArray<T> = [T, ...T[]];
+
+type TagMap = Partial<Record<IntrinsicTag | (string & {}), ClassName>>;
+
+type StrictMode = boolean | 'warn' | 'async-warn' | 'throw';
+
+type CardinalityInput = {
+    min?: number;
+    max?: number;
+};
+
+type ChildRuleMatch<T, U extends T = T> = (child: T) => child is U;
+
+type ChildRulePosition = 'first' | 'last' | 'any';
+
+type ChildRuleInput<T = unknown, U extends T = T> = {
+    name: string;
+    match: ChildRuleMatch<T, U>;
+    cardinality?: CardinalityInput;
+    position?: ChildRulePosition;
+    /**
+     * Optional component-type reference for O(1) dispatch index.
+     * When provided for every rule, the matcher reads child.type instead of
+     * calling every match function on every child (O(n×m) → O(n+m)).
+     */
+    type?: unknown;
+};
+
+type ValidResult = {
+    valid: true;
+};
+
+type StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;
+
+type VariantValue = string | string[];
+
+type VariantStates<K extends string = string> = Record<K, VariantValue>;
+
+type VariantMap<V extends string = string, K extends string = string> = Record<V, VariantStates<K>>;
+
+type VariantKey<V extends VariantMap, K extends keyof V> = StringToBoolean<keyof V[K] & string>;
+
+type RequireAtLeastOneIfNotEmpty<T> = keyof T extends never ? EmptyRecord : RequireAtLeastOne<T>;
+type CompoundVariantConditionValue<V extends VariantMap, K extends keyof V> = VariantKey<V, K> | NonEmptyArray<VariantKey<V, K>>;
+type CompoundVariantConditions<V extends VariantMap> = Simplify<{
+    [K in keyof V]: CompoundVariantConditionValue<V, K>;
+}>;
+type CompoundVariantRequiredConditions<V extends VariantMap> = RequireAtLeastOneIfNotEmpty<CompoundVariantConditions<V>>;
+type CompoundVariantBase<V extends VariantMap> = keyof V extends never ? EmptyRecord : CompoundVariantRequiredConditions<V>;
+type CompoundVariant<V extends VariantMap> = CompoundVariantBase<V> & {
+    class: VariantValue;
+};
+
+interface CVACompounds<V extends VariantMap> {
+    compoundVariants?: readonly CompoundVariant<V>[];
+}
+
+/** The full optional prop surface exposed to callers for a given variant map. */
+type VariantProps<V extends VariantMap> = {
+    [K in keyof V]?: VariantKey<V, K>;
+};
+type DefaultVariants<V extends VariantMap> = {
+    [K in keyof V]?: VariantKey<V, K>;
+};
+
+interface CVADefaults<V extends VariantMap> {
+    defaultVariants?: DefaultVariants<V>;
+}
+
+interface CVAVariants<V extends VariantMap> {
+    variants?: V;
+}
+
+/**
+ * A partial selection of variant states authored at factory definition time.
+ *
+ * Uses `keyof V[K]` directly (not `VariantKey`) so TypeScript can eagerly
+ * resolve the union at constraint-check time without deferred conditional types.
+ */
+type VariantSelection<V extends VariantMap> = {
+    [K in keyof V]?: keyof V[K];
+};
+
+/**
+ * A static, immutable map of named presets to partial variant selections.
+ *
+ * Presets are named bundles of variant props that callers activate by key,
+ * avoiding the need to repeat variant combinations at each call site.
+ */
+type PresetMap<V extends VariantMap = VariantMap> = Readonly<Record<string, VariantSelection<V>>>;
+
+interface PolymorphicGenerics<TDefault extends ElementType = ElementType, Props extends AnyRecord = AnyRecord, Variants extends Readonly<VariantMap> = Readonly<VariantMap>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>, TAllowed extends ElementType = ElementType> {
+    default: TDefault;
+    props: Props;
+    variants: Variants;
+    preset: TPreset;
+    allowed: TAllowed;
+}
+type VariantsOf<T extends PolymorphicGenerics> = T['variants'];
+type PresetOf<T extends PolymorphicGenerics> = T['preset'];
+type AllowedOf<T extends PolymorphicGenerics> = T['allowed'];
+
+type PresetTarget<TVariants extends VariantMap = VariantMap> = VariantSelection<TVariants>;
+
+interface BaseClassOptions {
+    baseClassName?: ClassName;
+}
+
+type ClassPipelineFn = (tag: unknown, props: AnyRecord, className?: ClassName, variantKey?: string) => string;
+
+interface PresetOptions<TVariants extends VariantMap = VariantMap> {
+    presetMap?: Record<string, PresetTarget<TVariants>>;
+}
+
+interface TagMapOptions {
+    tagMap?: TagMap;
+}
+
+type CompositionOptions<TVariants extends VariantMap = VariantMap> = Simplify<TagMapOptions & PresetOptions<TVariants>>;
+
+type CVASystemOptions<TVariants extends VariantMap = VariantMap> = Simplify<CVAVariants<TVariants> & CVADefaults<TVariants> & CVACompounds<TVariants>>;
+
+type StyleOptions<TVariants extends VariantMap = VariantMap> = Simplify<BaseClassOptions & CVASystemOptions<TVariants>>;
+
+type ClassPipelineOptions<TVariants extends VariantMap = VariantMap> = Simplify<StyleOptions<TVariants> & CompositionOptions<TVariants>>;
+
+type OwnedPropKeys = ReadonlySet<string>;
+
+type ClassPlugin<TProps extends AnyRecord = EmptyRecord> = Readonly<{
+    pipeline: ClassPipelineFn;
+    ownedKeys?: OwnedPropKeys;
+    readonly _pluginProps?: TProps;
+}>;
+
+type ClassPluginFactory<TProps extends AnyRecord = EmptyRecord> = <V extends VariantMap>(options: ClassPipelineOptions<V>, strict: StrictMode) => ClassPlugin<TProps>;
+
+type AriaContext = {
+    readonly tag: IntrinsicTag;
+    readonly implicitRole: AriaRole | undefined;
+    readonly effectiveRole: string | undefined;
+    readonly props: ReadonlyDeep<IntrinsicProps>;
+};
+
+type RemoveAttributeFixKind = `removeAttribute:${string}`;
+type InjectLiveFixKind = `injectLive:${string}`;
+type FixKind = 'removeRole' | 'setRole' | 'normalizeRelevantAll' | RemoveAttributeFixKind | InjectLiveFixKind;
+
+type AriaFixResult = {
+    applied: false;
+    next: ReadonlyDeep<IntrinsicProps>;
+} | {
+    applied: true;
+    next: ReadonlyDeep<IntrinsicProps>;
+    previous: ReadonlyDeep<IntrinsicProps>;
+};
+type AriaFix = {
+    readonly kind: FixKind;
+    readonly priority?: number;
+    readonly source?: string;
+    readonly apply: (context: AriaContext) => AriaFixResult;
+};
+
+type Severity = 'error' | 'warning' | (string & {});
+
+type AriaInvalidBase<M extends string = string> = {
+    valid: false;
+    severity: Severity;
+    message: M;
+    attribute?: string;
+};
+type AriaInvalidWithFix<M extends string = string> = AriaInvalidBase<M> & {
+    fixable: true;
+    fix: AriaFix;
+};
+type AriaInvalidWithoutFix<M extends string = string> = AriaInvalidBase<M> & {
+    fixable: false;
+};
+type AriaInvalidResult<M extends string = string> = AriaInvalidWithFix<M> | AriaInvalidWithoutFix<M>;
+type AriaResult = ValidResult | AriaInvalidResult;
+
+type AriaRule<C extends AriaContext = AriaContext> = (context: C) => readonly AriaResult[];
+
+type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
+
+type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
+    readonly strict?: StrictMode;
+    readonly aria?: readonly AriaRule[];
+    readonly children?: readonly ChildRuleInput[];
+    readonly props?: readonly PropNormalizer[];
+    /** Restricts the `as` prop to this set of tags. Violations route through strict mode. */
+    readonly allowedAs?: readonly TAllowed[];
+};
+
+type StylingOptions<V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord> = {
+    readonly base?: ClassName;
+    readonly variants?: V;
+    readonly defaults?: Partial<VariantProps<V>>;
+    readonly compounds?: readonly CompoundVariant<V>[];
+    readonly presets?: TPreset;
+    readonly tags?: Readonly<TagMap>;
+    readonly plugin?: ClassPluginFactory<TPluginProps>;
+    readonly precomputedClasses?: Readonly<Record<string, string>>;
+};
+
+type NormalizeFn<Props extends AnyRecord = AnyRecord> = {
+    normalize(props: Readonly<Props & IntrinsicProps>): Props & IntrinsicProps;
+}['normalize'];
+type FactoryOptions<TDefault extends ElementType = ElementType, Props extends AnyRecord = EmptyRecord, V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord, TAllowed extends ElementType = ElementType> = {
+    readonly tag?: TDefault;
+    readonly name?: string;
+    readonly defaults?: Partial<NoInfer<Props>>;
+    readonly normalize?: NormalizeFn<NoInfer<Props>>;
+    readonly styling?: StylingOptions<V, TPreset, TPluginProps>;
+    readonly enforcement?: EnforcementOptions<TAllowed>;
+};
+
+declare const disabledProps: PropNormalizer;
+
+declare const invalidProps: PropNormalizer;
+
+type DefaultOf<T extends PolymorphicGenerics> = T['default'];
+type PropsOf<T extends PolymorphicGenerics> = T['props'];
+
+type UnknownProps = Record<string, unknown>;
+type SlotComponent = ComponentType<UnknownProps>;
+
+/**
+ * Props passed to the `render` callback — the component's resolved className,
+ * filtered own props, and ref. Spread these onto the target element.
+ *
+ * Typed loosely to accommodate any element tag the user chooses.
+ */
+type RenderCallbackProps = Readonly<Record<string, unknown>>;
+
+/**
+ * Extends FactoryOptions with React-specific configuration.
+ * slotComponent is intentionally not in core — it is a React rendering concern.
+ */
+type ReactFactoryOptions<TDefault extends ElementType, Props extends UnknownProps, Variants extends Readonly<VariantMap>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord, TAllowed extends ElementType = ElementType> = FactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps, TAllowed> & {
+    /** Component used to render the asChild slot. Defaults to the built-in Slot. */
+    slotComponent?: SlotComponent;
+    /**
+     * Return true for any prop key that should be consumed but not forwarded to the DOM.
+     * The adapter strips nothing by default — implementations decide what is safe to drop.
+     * Receives `runtime.options.variantKeys` as a convenience if needed.
+     */
+    filterProps?: (key: string, variantKeys: ReadonlySet<string>) => boolean;
+};
+
+type SlottableProps = PropsWithChildren;
+declare function Slottable({ children }: SlottableProps): ReactElement;
+
+/** Maps a core ElementType to its DOM instance type for ref inference. */
+type ElementRef<T extends ElementType> = T extends IntrinsicTag ? HTMLElementTagNameMap[T] : unknown;
+/** @internal React JSX intrinsic props for a given element type. */
+type IntrinsicJSXProps<T extends ElementType> = T extends IntrinsicTag ? JSX.IntrinsicElements[T] : UnknownProps;
+/**
+ * @internal
+ * Removes index signatures (e.g. `[key: string]: T`) from a type, keeping only
+ * explicitly named properties. Used to prevent fallback-to-constraint generics
+ * like `Record<string, unknown>` or `Readonly<VariantMap>` from producing a
+ * `[key: string]: T` member that makes `keyof` resolve to `string` — which
+ * would cause `Omit<IntrinsicJSXProps<TAs>, string>` to remove all HTML props.
+ */
+type StripIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : K]: T[K];
+};
+type ComponentProps<G extends PolymorphicGenerics> = StripIndexSignature<PropsOf<G>>;
+type ComponentVariants<G extends PolymorphicGenerics> = StripIndexSignature<VariantProps<VariantsOf<G>>>;
+type OwnedProps<G extends PolymorphicGenerics> = ComponentProps<G> & ComponentVariants<G>;
+/**
+ * @internal
+ * Polymorphic machinery props. Separated from `OwnedProps` so the two concerns
+ * are distinct: user-defined props vs. the tag/ref/class system.
+ *
+ * `asChild` and `children` are excluded — typed separately in the discriminated
+ * union below so each render mode can enforce different child constraints.
+ */
+type PolymorphicControlProps<G extends PolymorphicGenerics, TAs extends ElementType> = {
+    as?: TAs & AllowedOf<G>;
+    className?: ClassName | undefined;
+    variantKey?: keyof PresetOf<G>;
+    ref?: Ref<ElementRef<TAs>>;
+};
+/** @internal Full set of props owned by the component — used as the Omit key in IntrinsicPropsWithoutOwned. */
+type ControlProps<G extends PolymorphicGenerics, TAs extends ElementType> = OwnedProps<G> & PolymorphicControlProps<G, TAs>;
+type IntrinsicPropsWithoutOwned<G extends PolymorphicGenerics, TAs extends ElementType> = Omit<IntrinsicJSXProps<TAs>, keyof ControlProps<G, TAs> | 'children'>;
+type SharedProps<G extends PolymorphicGenerics, TAs extends ElementType> = IntrinsicPropsWithoutOwned<G, TAs> & ControlProps<G, TAs>;
+/** Discriminant for the normal render path: `asChild` absent or false, any children. */
+type NormalRenderMode = {
+    asChild?: false;
+    children?: ReactNode | undefined;
+};
+/**
+ * Discriminant for the slot render path. One or more `ReactElement` children required.
+ * `as` is forbidden — combining `as` with `asChild` is a runtime invariant violation.
+ */
+type SlotRenderMode = {
+    asChild: true;
+    as?: never;
+    children: ReactElement | NonEmptyTuple<ReactElement>;
+};
+/**
+ * Discriminant for the render-prop path. The callback receives all resolved props
+ * (className, ref, filtered component props) and returns the target element.
+ *
+ * This is the output form for the compile-time `asChild` transform: keeps the same
+ * rendering flexibility as `asChild` without the `cloneElement` cost at runtime.
+ * Unlike `asChild`, the render callback does not auto-merge conflicting event
+ * handlers — spread position determines precedence.
+ *
+ * ```tsx
+ * <Button render={(p) => <a href="/home" {...p} />} size="lg" />
+ * ```
+ */
+type CallbackRenderMode = {
+    render: (props: RenderCallbackProps) => ReactElement;
+    asChild?: never;
+    children?: never;
+};
+/**
+ * Props for the normal render path. HTML attributes are inferred from `TAs`.
+ *
+ * `Omit + intersection` (not `Merge`) is used so TypeScript can infer `TAs` from
+ * the `as` prop value; control props win on key conflicts.
+ */
+type PolymorphicProps<G extends PolymorphicGenerics, TAs extends ElementType = DefaultOf<G>> = Simplify<SharedProps<G, TAs> & NormalRenderMode>;
+/**
+ * Props for the slot render path (`asChild: true`). One or more `ReactElement`
+ * children are required. Multiple children are permitted for the Slottable
+ * sibling pattern where one child is a `<Slottable>` wrapper.
+ */
+type PolymorphicWithAsChild<G extends PolymorphicGenerics, TAs extends ElementType = DefaultOf<G>> = Simplify<SharedProps<G, TAs> & SlotRenderMode>;
+type PolymorphicWithRender<G extends PolymorphicGenerics, TAs extends ElementType = DefaultOf<G>> = Simplify<SharedProps<G, TAs> & CallbackRenderMode>;
+/**
+ * A polymorphic component that infers HTML attributes and ref type from the `as` prop.
+ *
+ * Three call signatures form a discriminated union:
+ * - `render` present       → render-prop path; no Slot or cloneElement at runtime
+ * - `asChild: true`        → slot path; exactly one `ReactElement` child required
+ * - `asChild?: false`      → normal path; any `ReactNode` children accepted
+ */
+type PolymorphicComponent<G extends PolymorphicGenerics> = {
+    <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicWithRender<G, TAs>): ReactElement;
+    <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicWithAsChild<G, TAs>): ReactElement;
+    <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicProps<G, TAs>): ReactElement;
+    displayName?: string;
+};
+
+declare function mergeRefs<T>(...refs: (Ref<T> | null | undefined)[]): Ref<T> | null;
+
+export { type AnyRecord as A, type ElementType as E, type FactoryOptions as F, type PresetMap as P, type ReactFactoryOptions as R, Slottable as S, type UnknownProps as U, type VariantMap as V, type EmptyRecord as a, type PolymorphicComponent as b, type PolymorphicGenerics as c, type ElementRef as d, type PolymorphicProps as e, type PolymorphicWithAsChild as f, type PolymorphicWithRender as g, type RenderCallbackProps as h, type SlottableProps as i, disabledProps as j, invalidProps as k, mergeRefs as m };

package/dist/preact/index.d.ts

@@ -0,0 +1,292 @@
+import { RequireAtLeastOne, Simplify, ReadonlyDeep, OmitIndexSignature } from 'type-fest';
+import { VNode, ComponentType, JSX, Ref, ComponentChildren } from 'preact';
+
+type AnyRecord = Record<string, unknown>;
+
+type IntrinsicTag = keyof HTMLElementTagNameMap;
+
+type ElementType = IntrinsicTag | (string & {});
+
+declare const KNOWN_ARIA_ROLES: readonly ["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"];
+type KnownAriaRole = (typeof KNOWN_ARIA_ROLES)[number];
+
+type AriaRole = KnownAriaRole | (string & {});
+
+type ClassName = string | string[];
+
+type EmptyRecord = Record<never, never>;
+
+type IntrinsicProps = AnyRecord & {
+    role?: AriaRole;
+};
+
+type NonEmptyArray<T> = [T, ...T[]];
+
+type TagMap = Partial<Record<IntrinsicTag | (string & {}), ClassName>>;
+
+type StrictMode = boolean | 'warn' | 'async-warn' | 'throw';
+
+type CardinalityInput = {
+    min?: number;
+    max?: number;
+};
+
+type ChildRuleMatch<T, U extends T = T> = (child: T) => child is U;
+
+type ChildRulePosition = 'first' | 'last' | 'any';
+
+type ChildRuleInput<T = unknown, U extends T = T> = {
+    name: string;
+    match: ChildRuleMatch<T, U>;
+    cardinality?: CardinalityInput;
+    position?: ChildRulePosition;
+    /**
+     * Optional component-type reference for O(1) dispatch index.
+     * When provided for every rule, the matcher reads child.type instead of
+     * calling every match function on every child (O(n×m) → O(n+m)).
+     */
+    type?: unknown;
+};
+
+type ValidResult = {
+    valid: true;
+};
+
+type StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;
+
+type VariantValue = string | string[];
+
+type VariantStates<K extends string = string> = Record<K, VariantValue>;
+
+type VariantMap<V extends string = string, K extends string = string> = Record<V, VariantStates<K>>;
+
+type VariantKey<V extends VariantMap, K extends keyof V> = StringToBoolean<keyof V[K] & string>;
+
+type RequireAtLeastOneIfNotEmpty<T> = keyof T extends never ? EmptyRecord : RequireAtLeastOne<T>;
+type CompoundVariantConditionValue<V extends VariantMap, K extends keyof V> = VariantKey<V, K> | NonEmptyArray<VariantKey<V, K>>;
+type CompoundVariantConditions<V extends VariantMap> = Simplify<{
+    [K in keyof V]: CompoundVariantConditionValue<V, K>;
+}>;
+type CompoundVariantRequiredConditions<V extends VariantMap> = RequireAtLeastOneIfNotEmpty<CompoundVariantConditions<V>>;
+type CompoundVariantBase<V extends VariantMap> = keyof V extends never ? EmptyRecord : CompoundVariantRequiredConditions<V>;
+type CompoundVariant<V extends VariantMap> = CompoundVariantBase<V> & {
+    class: VariantValue;
+};
+
+interface CVACompounds<V extends VariantMap> {
+    compoundVariants?: readonly CompoundVariant<V>[];
+}
+
+/** The full optional prop surface exposed to callers for a given variant map. */
+type VariantProps<V extends VariantMap> = {
+    [K in keyof V]?: VariantKey<V, K>;
+};
+type DefaultVariants<V extends VariantMap> = {
+    [K in keyof V]?: VariantKey<V, K>;
+};
+
+interface CVADefaults<V extends VariantMap> {
+    defaultVariants?: DefaultVariants<V>;
+}
+
+interface CVAVariants<V extends VariantMap> {
+    variants?: V;
+}
+
+/**
+ * A partial selection of variant states authored at factory definition time.
+ *
+ * Uses `keyof V[K]` directly (not `VariantKey`) so TypeScript can eagerly
+ * resolve the union at constraint-check time without deferred conditional types.
+ */
+type VariantSelection<V extends VariantMap> = {
+    [K in keyof V]?: keyof V[K];
+};
+
+/**
+ * A static, immutable map of named presets to partial variant selections.
+ *
+ * Presets are named bundles of variant props that callers activate by key,
+ * avoiding the need to repeat variant combinations at each call site.
+ */
+type PresetMap<V extends VariantMap = VariantMap> = Readonly<Record<string, VariantSelection<V>>>;
+
+interface PolymorphicGenerics<TDefault extends ElementType = ElementType, Props extends AnyRecord = AnyRecord, Variants extends Readonly<VariantMap> = Readonly<VariantMap>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>, TAllowed extends ElementType = ElementType> {
+    default: TDefault;
+    props: Props;
+    variants: Variants;
+    preset: TPreset;
+    allowed: TAllowed;
+}
+type VariantsOf<T extends PolymorphicGenerics> = T['variants'];
+type PresetOf<T extends PolymorphicGenerics> = T['preset'];
+
+type PresetTarget<TVariants extends VariantMap = VariantMap> = VariantSelection<TVariants>;
+
+interface BaseClassOptions {
+    baseClassName?: ClassName;
+}
+
+type ClassPipelineFn = (tag: unknown, props: AnyRecord, className?: ClassName, variantKey?: string) => string;
+
+interface PresetOptions<TVariants extends VariantMap = VariantMap> {
+    presetMap?: Record<string, PresetTarget<TVariants>>;
+}
+
+interface TagMapOptions {
+    tagMap?: TagMap;
+}
+
+type CompositionOptions<TVariants extends VariantMap = VariantMap> = Simplify<TagMapOptions & PresetOptions<TVariants>>;
+
+type CVASystemOptions<TVariants extends VariantMap = VariantMap> = Simplify<CVAVariants<TVariants> & CVADefaults<TVariants> & CVACompounds<TVariants>>;
+
+type StyleOptions<TVariants extends VariantMap = VariantMap> = Simplify<BaseClassOptions & CVASystemOptions<TVariants>>;
+
+type ClassPipelineOptions<TVariants extends VariantMap = VariantMap> = Simplify<StyleOptions<TVariants> & CompositionOptions<TVariants>>;
+
+type OwnedPropKeys = ReadonlySet<string>;
+
+type ClassPlugin<TProps extends AnyRecord = EmptyRecord> = Readonly<{
+    pipeline: ClassPipelineFn;
+    ownedKeys?: OwnedPropKeys;
+    readonly _pluginProps?: TProps;
+}>;
+
+type ClassPluginFactory<TProps extends AnyRecord = EmptyRecord> = <V extends VariantMap>(options: ClassPipelineOptions<V>, strict: StrictMode) => ClassPlugin<TProps>;
+
+type AriaContext = {
+    readonly tag: IntrinsicTag;
+    readonly implicitRole: AriaRole | undefined;
+    readonly effectiveRole: string | undefined;
+    readonly props: ReadonlyDeep<IntrinsicProps>;
+};
+
+type RemoveAttributeFixKind = `removeAttribute:${string}`;
+type InjectLiveFixKind = `injectLive:${string}`;
+type FixKind = 'removeRole' | 'setRole' | 'normalizeRelevantAll' | RemoveAttributeFixKind | InjectLiveFixKind;
+
+type AriaFixResult = {
+    applied: false;
+    next: ReadonlyDeep<IntrinsicProps>;
+} | {
+    applied: true;
+    next: ReadonlyDeep<IntrinsicProps>;
+    previous: ReadonlyDeep<IntrinsicProps>;
+};
+type AriaFix = {
+    readonly kind: FixKind;
+    readonly priority?: number;
+    readonly source?: string;
+    readonly apply: (context: AriaContext) => AriaFixResult;
+};
+
+type Severity = 'error' | 'warning' | (string & {});
+
+type AriaInvalidBase<M extends string = string> = {
+    valid: false;
+    severity: Severity;
+    message: M;
+    attribute?: string;
+};
+type AriaInvalidWithFix<M extends string = string> = AriaInvalidBase<M> & {
+    fixable: true;
+    fix: AriaFix;
+};
+type AriaInvalidWithoutFix<M extends string = string> = AriaInvalidBase<M> & {
+    fixable: false;
+};
+type AriaInvalidResult<M extends string = string> = AriaInvalidWithFix<M> | AriaInvalidWithoutFix<M>;
+type AriaResult = ValidResult | AriaInvalidResult;
+
+type AriaRule<C extends AriaContext = AriaContext> = (context: C) => readonly AriaResult[];
+
+type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
+
+type EnforcementOptions<TAllowed extends ElementType = ElementType> = {
+    readonly strict?: StrictMode;
+    readonly aria?: readonly AriaRule[];
+    readonly children?: readonly ChildRuleInput[];
+    readonly props?: readonly PropNormalizer[];
+    /** Restricts the `as` prop to this set of tags. Violations route through strict mode. */
+    readonly allowedAs?: readonly TAllowed[];
+};
+
+type StylingOptions<V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord> = {
+    readonly base?: ClassName;
+    readonly variants?: V;
+    readonly defaults?: Partial<VariantProps<V>>;
+    readonly compounds?: readonly CompoundVariant<V>[];
+    readonly presets?: TPreset;
+    readonly tags?: Readonly<TagMap>;
+    readonly plugin?: ClassPluginFactory<TPluginProps>;
+    readonly precomputedClasses?: Readonly<Record<string, string>>;
+};
+
+type NormalizeFn<Props extends AnyRecord = AnyRecord> = {
+    normalize(props: Readonly<Props & IntrinsicProps>): Props & IntrinsicProps;
+}['normalize'];
+type FactoryOptions<TDefault extends ElementType = ElementType, Props extends AnyRecord = EmptyRecord, V extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<V> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord, TAllowed extends ElementType = ElementType> = {
+    readonly tag?: TDefault;
+    readonly name?: string;
+    readonly defaults?: Partial<NoInfer<Props>>;
+    readonly normalize?: NormalizeFn<NoInfer<Props>>;
+    readonly styling?: StylingOptions<V, TPreset, TPluginProps>;
+    readonly enforcement?: EnforcementOptions<TAllowed>;
+};
+
+declare const disabledProps: PropNormalizer;
+
+declare const invalidProps: PropNormalizer;
+
+type DefaultOf<T extends PolymorphicGenerics> = T['default'];
+type PropsOf<T extends PolymorphicGenerics> = T['props'];
+
+type UnknownProps = Record<string, unknown>;
+type SlotComponent = ComponentType<UnknownProps>;
+type AnyVNode = VNode<any>;
+
+type PreactFactoryOptions<TDefault extends ElementType, Props extends UnknownProps, Variants extends Readonly<VariantMap>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord> = FactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps> & {
+    /** Component used to render the asChild slot. Defaults to the built-in Slot. */
+    slotComponent?: SlotComponent;
+    /**
+     * Return true for any prop key that should be consumed but not forwarded to the DOM.
+     * Receives `runtime.options.variantKeys` as a convenience if needed.
+     */
+    filterProps?: (key: string, variantKeys: ReadonlySet<string>) => boolean;
+};
+
+type ElementRef<T extends ElementType> = T extends IntrinsicTag ? HTMLElementTagNameMap[T] : unknown;
+type IntrinsicJSXProps<T extends ElementType> = T extends IntrinsicTag ? JSX.IntrinsicElements[T] : UnknownProps;
+type ControlProps<G extends PolymorphicGenerics, TAs extends ElementType> = OmitIndexSignature<PropsOf<G>> & OmitIndexSignature<VariantProps<VariantsOf<G>>> & {
+    as?: TAs;
+    className?: ClassName | undefined;
+    variantKey?: keyof PresetOf<G>;
+    ref?: Ref<ElementRef<TAs>>;
+};
+type SharedProps<G extends PolymorphicGenerics, TAs extends ElementType> = Omit<IntrinsicJSXProps<TAs>, keyof ControlProps<G, TAs> | 'children'> & ControlProps<G, TAs>;
+type PolymorphicProps<G extends PolymorphicGenerics, TAs extends ElementType = DefaultOf<G>> = Simplify<SharedProps<G, TAs> & {
+    asChild?: false;
+    children?: unknown;
+}>;
+type PolymorphicWithAsChild<G extends PolymorphicGenerics, TAs extends ElementType = DefaultOf<G>> = Simplify<SharedProps<G, TAs> & {
+    asChild: true;
+    as?: never;
+    children: AnyVNode | AnyVNode[];
+}>;
+type PolymorphicComponent<G extends PolymorphicGenerics> = {
+    <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicWithAsChild<G, TAs>): AnyVNode;
+    <TAs extends ElementType = DefaultOf<G>>(props: PolymorphicProps<G, TAs>): AnyVNode;
+    displayName?: string;
+};
+
+declare function createContractComponent<TDefault extends ElementType, Props extends UnknownProps = EmptyRecord, Variants extends Readonly<VariantMap> = Readonly<EmptyRecord>, TPreset extends PresetMap<Variants> = Readonly<EmptyRecord>, TPluginProps extends AnyRecord = EmptyRecord>(options: PreactFactoryOptions<TDefault, Props, Variants, TPreset, TPluginProps>): PolymorphicComponent<PolymorphicGenerics<TDefault, Props & TPluginProps, Variants, TPreset>>;
+
+declare function defineContractComponent<O extends FactoryOptions>(options: O): <R>(factory: (options: O) => R) => R;
+
+type SlottableProps = {
+    children?: ComponentChildren;
+};
+declare function Slottable({ children }: SlottableProps): AnyVNode;
+
+export { type ElementRef, type PolymorphicComponent, type PolymorphicProps, type PolymorphicWithAsChild, type PreactFactoryOptions, Slottable, createContractComponent, defineContractComponent, disabledProps, invalidProps };