@vireo-ai/trellis-ui 0.1.0

package/types/components/text/contract.d.ts

@@ -0,0 +1,10 @@
+declare const TEXT_AS_VALUES: readonly ["span", "p", "div", "label", "kbd", "code", "strong"];
+declare const TEXT_SIZE_VALUES: readonly ["xs", "sm", "base", "lg", "xl", "2xl"];
+declare const TEXT_WEIGHT_VALUES: readonly ["normal", "medium", "semibold", "bold"];
+declare const TEXT_COLOR_VALUES: readonly ["default", "muted", "subtle", "danger", "inherit"];
+type TextAs = typeof TEXT_AS_VALUES[number];
+type TextSize = typeof TEXT_SIZE_VALUES[number];
+type TextWeight = typeof TEXT_WEIGHT_VALUES[number];
+type TextColor = typeof TEXT_COLOR_VALUES[number];
+export { TEXT_AS_VALUES, TEXT_COLOR_VALUES, TEXT_SIZE_VALUES, TEXT_WEIGHT_VALUES, };
+export type { TextAs, TextColor, TextSize, TextWeight };

package/types/components/textarea/contract.d.ts

@@ -0,0 +1,22 @@
+import { type PropState } from '../../runtime';
+declare const TEXTAREA_RESIZE_VALUES: readonly ["vertical", "horizontal", "both", "none"];
+type TextareaResize = typeof TEXTAREA_RESIZE_VALUES[number];
+declare const textareaSchema: {
+    name: import("../../runtime/codecs").StringCodec;
+    value: import("../../runtime/codecs").StringCodec;
+    placeholder: import("../../runtime/codecs").StringCodec;
+    size: import("../../runtime/codecs").OneOfCodec<"xs" | "sm" | "md" | "lg" | "xlg">;
+    variant: import("../../runtime/codecs").OneOfCodec<"outline" | "filled">;
+    rows: import("../../runtime/codecs").NumberCodec;
+    resize: import("../../runtime/codecs").OneOfCodec<"none" | "vertical" | "horizontal" | "both">;
+    disabled: import("../../runtime/codecs").BoolCodec;
+    readonly: import("../../runtime/codecs").BoolCodec;
+    required: import("../../runtime/codecs").BoolCodec;
+    invalid: import("../../runtime/codecs").BoolCodec;
+    rootClass: import("../../runtime/codecs").StringCodec;
+    controlClass: import("../../runtime/codecs").StringCodec;
+    class: import("../../runtime/codecs").StringCodec;
+};
+type TextareaProps = PropState<typeof textareaSchema>;
+export { textareaSchema, TEXTAREA_RESIZE_VALUES };
+export type { TextareaProps, TextareaResize };

package/types/components/theme/contract.d.ts

@@ -0,0 +1,6 @@
+declare const themeTextSchema: {
+    light: import("../../runtime/codecs").StringCodec;
+    dark: import("../../runtime/codecs").StringCodec;
+    class: import("../../runtime/codecs").StringCodec;
+};
+export { themeTextSchema };

package/types/components/toast/contract.d.ts

@@ -0,0 +1,28 @@
+import { type PropState } from '../../runtime';
+declare const TOAST_LEVELS: readonly ["info", "success", "warning", "danger", "debug"];
+declare const TOAST_VARIANTS: readonly ["default", "info", "success", "warning", "danger", "debug"];
+declare const TOAST_POSITIONS: readonly ["top-right", "top-left", "top-center", "bottom-right", "bottom-left", "bottom-center"];
+declare const toastSchema: {
+    level: import("../../runtime/codecs").OneOfCodec<"success" | "warning" | "danger" | "info" | "debug">;
+    variant: import("../../runtime/codecs").OneOfCodec<"default" | "success" | "warning" | "danger" | "info" | "debug">;
+    title: import("../../runtime/codecs").StringCodec;
+    duration: import("../../runtime/codecs").NumberCodec;
+    dismissible: import("../../runtime/codecs").BoolCodec;
+    class: import("../../runtime/codecs").StringCodec;
+    contentClass: import("../../runtime/codecs").StringCodec;
+    closeClass: import("../../runtime/codecs").StringCodec;
+};
+declare const toastOutletSchema: {
+    id: import("../../runtime/codecs").StringCodec;
+    position: import("../../runtime/codecs").OneOfCodec<"top-right" | "top-left" | "top-center" | "bottom-right" | "bottom-left" | "bottom-center">;
+    duration: import("../../runtime/codecs").NumberCodec;
+    includeMessages: import("../../runtime/codecs").BoolCodec;
+    class: import("../../runtime/codecs").StringCodec;
+};
+type ToastLevel = typeof TOAST_LEVELS[number];
+type ToastVariant = typeof TOAST_VARIANTS[number];
+type ToastPosition = typeof TOAST_POSITIONS[number];
+type ToastProps = PropState<typeof toastSchema>;
+type ToastOutletProps = PropState<typeof toastOutletSchema>;
+export { TOAST_LEVELS, TOAST_POSITIONS, TOAST_VARIANTS, toastOutletSchema, toastSchema };
+export type { ToastLevel, ToastOutletProps, ToastPosition, ToastProps, ToastVariant };

package/types/components/toast/index.d.ts

@@ -0,0 +1,27 @@
+import type Alpine from 'alpinejs';
+import { type CleanupStack, type TrellisAlpineComponent } from '../../runtime';
+import { type ToastOutletProps, type ToastProps } from './contract';
+type ToastDetail = {
+    message?: unknown;
+    title?: unknown;
+    level?: unknown;
+    variant?: unknown;
+    duration?: unknown;
+    dismissible?: unknown;
+};
+type ToastData = {
+    props: ToastProps;
+    cleanup: CleanupStack;
+    timer: number | null;
+    dismiss(): void;
+};
+type ToastOutletData = {
+    props: ToastOutletProps;
+    cleanup: CleanupStack;
+    add(detail: ToastDetail): void;
+};
+declare const UiToast: () => TrellisAlpineComponent<ToastData>;
+declare const UiToastOutlet: () => TrellisAlpineComponent<ToastOutletData>;
+declare const registerToast: (AlpineInstance: Alpine.Alpine) => void;
+export { registerToast, UiToast, UiToastOutlet };
+export type { ToastData, ToastDetail, ToastOutletData };

package/types/index.d.ts

@@ -0,0 +1,46 @@
+import type { Alpine as AlpineType } from 'alpinejs';
+import { motion } from './motion';
+import { bool, className, create, createResizable, cx, defineManifest, defineProps, defineStyles, json, number, oneOf, props, propsFromSchema, resolveStyle, string } from './runtime';
+type TrellisUIPlugin = (AlpineInstance: AlpineType) => void;
+declare const ui: {
+    readonly bool: import("./runtime/codecs").BoolCodec;
+    readonly className: ({ values }: import("./runtime").ClassNameOptions) => string;
+    readonly create: <const T extends Record<string, import("./runtime").StyleTree>>({ definition }: import("./runtime").CreateOptions<T>) => Readonly<T>;
+    readonly createResizable: ({ element, handle, axis, min, max, step, mode, hitArea, coarseHitArea, disabled, onStart, onResize, onEnd, }: import("./runtime").ResizableOptions) => (() => void);
+    readonly cx: ({ values }: import("./runtime").ClassNameOptions) => string;
+    readonly defineManifest: <const T extends import("./runtime").ComponentManifest>({ manifest }: import("./runtime").DefineManifestOptions<T>) => Readonly<T>;
+    readonly defineProps: <T extends Record<string, import("./runtime").CodecFn<unknown>>>({ el, schema, }: import("./runtime/codecs").DefinePropsOptions<T>) => import("./runtime").PropState<T>;
+    readonly defineStyles: <const T extends import("./runtime").StyleDefinition>({ definition }: import("./runtime").DefineStylesOptions<T>) => Readonly<T>;
+    readonly json: import("./runtime/codecs").JsonCodecFactory;
+    readonly motion: {
+        readonly createAnimator: <T extends string | number>(value: import("motion").MotionValue<T> | T, defaultOptions?: import("motion").ValueAnimationTransition<T>) => import("./motion").Animator<T>;
+        readonly parallel: (...handles: import("./motion").MotionHandle[]) => import("./motion").MotionHandle;
+        readonly sequential: (...steps: Array<() => import("./motion").MotionHandle>) => import("./motion").MotionHandle;
+        readonly bindTransform: <T extends import("./motion").TransformContext>(element: HTMLElement, values: T, compose: import("./motion").TransformComposer<T>) => (() => void);
+        readonly bindStyle: <T extends string | number>(element: HTMLElement, property: keyof CSSStyleDeclaration, value: import("motion").MotionValue<T>, map?: (value: T) => string) => (() => void);
+        readonly withReducedMotion: <T extends import("motion").AnimationOptions>(options: T, reducedOptions?: Partial<T>, preference?: import("./motion").MotionPreference) => T;
+        readonly resolveTargets: (scope?: import("./motion").ViewScope, targets?: import("./motion").MotionTarget | import("./motion").MotionTarget[] | null) => Element[];
+        readonly applyViewKeys: (scope?: import("./motion").ViewScope, options?: {
+            key?: string;
+            layout?: boolean;
+        }) => (() => void);
+        readonly animateView: (update: () => void | Promise<void>, targets?: import("./motion").MotionTarget | import("./motion").MotionTarget[] | null, options?: import("./motion").AnimateViewOptions) => import("./motion").MotionHandle;
+        readonly animatePresence: (element: Element, phase: import("./motion").PresencePhase, preset?: import("./motion").PresenceDefinition, options?: import("./motion").PresenceOptions) => import("./motion").MotionHandle;
+        readonly createPresenceLifecycle: ({ element, preset, enter, exit, options, enterOptions, exitOptions, owner, }: import("./motion").PresenceLifecycleOptions) => import("./motion").PresenceLifecycle;
+        readonly animateStreamPatch: <AlpineInstance>(_Alpine: AlpineInstance, patchOrPatches: import("./motion/stream").StreamPatchLike | import("./motion/stream").StreamPatchLike[], options?: import("./motion").AnimateStreamPatchOptions) => import("./motion").MotionHandle;
+    };
+    readonly number: import("./runtime/codecs").NumberCodec;
+    readonly oneOf: <T extends string>(allowed: readonly T[], fallback: T) => import("./runtime/codecs").OneOfCodec<T>;
+    readonly props: ({ inputs }: import("./runtime").PropsOptions) => import("./runtime").BindingObject;
+    readonly propsFromSchema: <const T extends Record<string, import("./runtime").CodecFn<unknown>>>({ schema, details, }: import("./runtime").PropsFromSchemaOptions<T>) => Record<string, import("./runtime").ManifestProp>;
+    readonly resolveStyle: ({ part, props, className: override, }: import("./runtime").ResolveStyleOptions) => string;
+    readonly string: import("./runtime/codecs").StringCodec;
+};
+declare const trellisUi: TrellisUIPlugin;
+export { trellisUi, ui };
+export default trellisUi;
+export type { TrellisUIPlugin };
+export { motion };
+export { bool, className, create, createResizable, cx, defineManifest, defineProps, defineStyles, json, number, oneOf, props, propsFromSchema, resolveStyle, string, };
+export type { ClassArray, ClassDictionary, ClassNameOptions, ClassValue, CodecFn, ComponentManifest, CreateOptions, DefineManifestOptions, DefineStylesOptions, ManifestPart, ManifestProp, ManifestPropDetails, ManifestToken, PropInput, PropState, PropsFromSchemaOptions, PropsOptions, ResizableOptions, ResizeAxis, ResizeEvent, ResizeMode, ResizePhase, ResolveStyleOptions, SchemaPropDetails, SchemaToProps, StyleDefinition, StylePart, StyleProps, StyleTree, TrellisAlpineComponent, } from './runtime';
+export type { AnimateStreamPatchOptions, AnimateViewOptions, Animator, MotionHandle, MotionPreference, MotionTarget, PresenceDefinition, PresenceLifecycle, PresenceLifecycleCallbacks, PresenceLifecycleOptions, PresenceOptions, PresencePhase, PresencePreset, ResolvedViewTarget, TransformComposer, TransformContext, ViewPreset, ViewScope, } from './motion';

package/types/motion/animate.d.ts

@@ -0,0 +1,49 @@
+import { type AnimationPlaybackControls, type MotionValue, type ValueAnimationTransition } from 'motion';
+type MotionHandle = {
+    finished: Promise<void>;
+    cancel(): void;
+    stop(): void;
+    complete(): void;
+};
+type Animator<T extends string | number> = {
+    value: MotionValue<T>;
+    animateTo(to: T, options?: ValueAnimationTransition<T>): MotionHandle;
+};
+type TransformContext = Record<string, MotionValue<number>>;
+type TransformComposer<T extends TransformContext> = (ctx: T) => string;
+declare const noopHandle: (run?: () => void | Promise<void>) => MotionHandle;
+declare const toMotionHandle: (controls: Pick<AnimationPlaybackControls, "finished" | "cancel" | "stop" | "complete">, cleanup?: () => void) => MotionHandle;
+declare const createAnimator: <T extends string | number>(value: MotionValue<T> | T, defaultOptions?: ValueAnimationTransition<T>) => Animator<T>;
+declare const parallel: (...handles: MotionHandle[]) => MotionHandle;
+declare const sequential: (...steps: Array<() => MotionHandle>) => MotionHandle;
+declare const bindStyle: <T extends string | number>(element: HTMLElement, property: keyof CSSStyleDeclaration, value: MotionValue<T>, map?: (value: T) => string) => (() => void);
+declare const bindTransform: <T extends TransformContext>(element: HTMLElement, values: T, compose: TransformComposer<T>) => (() => void);
+declare const motionDurations: {
+    readonly fast: 0.14;
+    readonly normal: 0.18;
+    readonly slow: 0.24;
+};
+declare const motionEasings: {
+    readonly out: readonly [0.23, 1, 0.32, 1];
+    readonly inOut: readonly [0.77, 0, 0.175, 1];
+};
+declare const presenceOptions: {
+    popover: {
+        duration: 0.14;
+        ease: readonly [0.23, 1, 0.32, 1];
+    };
+    modal: {
+        duration: 0.24;
+        ease: readonly [0.23, 1, 0.32, 1];
+    };
+    toast: {
+        duration: 0.18;
+        ease: readonly [0.23, 1, 0.32, 1];
+    };
+    sidebar: {
+        duration: 0.24;
+        ease: readonly [0.23, 1, 0.32, 1];
+    };
+};
+export { bindStyle, bindTransform, createAnimator, motionDurations, motionEasings, noopHandle, parallel, presenceOptions, sequential, toMotionHandle, };
+export type { Animator, MotionHandle, TransformComposer, TransformContext };

package/types/motion/index.d.ts

@@ -0,0 +1,24 @@
+declare const motion: {
+    readonly createAnimator: <T extends string | number>(value: import("motion").MotionValue<T> | T, defaultOptions?: import("motion").ValueAnimationTransition<T>) => import("./animate").Animator<T>;
+    readonly parallel: (...handles: import("./animate").MotionHandle[]) => import("./animate").MotionHandle;
+    readonly sequential: (...steps: Array<() => import("./animate").MotionHandle>) => import("./animate").MotionHandle;
+    readonly bindTransform: <T extends import("./animate").TransformContext>(element: HTMLElement, values: T, compose: import("./animate").TransformComposer<T>) => (() => void);
+    readonly bindStyle: <T extends string | number>(element: HTMLElement, property: keyof CSSStyleDeclaration, value: import("motion").MotionValue<T>, map?: (value: T) => string) => (() => void);
+    readonly withReducedMotion: <T extends import("motion").AnimationOptions>(options: T, reducedOptions?: Partial<T>, preference?: import("./reduced-motion").MotionPreference) => T;
+    readonly resolveTargets: (scope?: import("./targets").ViewScope, targets?: import("./targets").MotionTarget | import("./targets").MotionTarget[] | null) => Element[];
+    readonly applyViewKeys: (scope?: import("./targets").ViewScope, options?: {
+        key?: string;
+        layout?: boolean;
+    }) => (() => void);
+    readonly animateView: (update: () => void | Promise<void>, targets?: import("./targets").MotionTarget | import("./targets").MotionTarget[] | null, options?: import("./view").AnimateViewOptions) => import("./animate").MotionHandle;
+    readonly animatePresence: (element: Element, phase: import("./presence").PresencePhase, preset?: import("./presence").PresenceDefinition, options?: import("./presence").PresenceOptions) => import("./animate").MotionHandle;
+    readonly createPresenceLifecycle: ({ element, preset, enter, exit, options, enterOptions, exitOptions, owner, }: import("./presence").PresenceLifecycleOptions) => import("./presence").PresenceLifecycle;
+    readonly animateStreamPatch: <AlpineInstance>(_Alpine: AlpineInstance, patchOrPatches: import("./stream").StreamPatchLike | import("./stream").StreamPatchLike[], options?: import("./stream").AnimateStreamPatchOptions) => import("./animate").MotionHandle;
+};
+export { motion };
+export { bindStyle, bindTransform, createAnimator, parallel, sequential, type Animator, type MotionHandle, type TransformComposer, type TransformContext, } from './animate';
+export { prefersReducedMotion, reducedMotionQuery, shouldReduceMotion, withReducedMotion, type MotionPreference, } from './reduced-motion';
+export { animatePresence, createPresenceLifecycle, type PresenceDefinition, type PresenceLifecycle, type PresenceLifecycleCallbacks, type PresenceLifecycleOptions, type PresenceOptions, type PresencePhase, type PresencePreset, } from './presence';
+export { animateStreamPatch, streamTargetsFromPatches, type AnimateStreamPatchOptions } from './stream';
+export { MOTION_ACTIVE_ATTR, MOTION_KEY_ATTR, MOTION_LAYOUT_ATTR, MOTION_TEMP_ATTR, applyViewKeys, resolveTargets, resolveViewTargets, type MotionTarget, type ResolvedViewTarget, type ViewScope, } from './targets';
+export { animateView, type AnimateViewOptions, type ViewPreset } from './view';

package/types/motion/presence.d.ts

@@ -0,0 +1,34 @@
+import { type AnimationOptions, type DOMKeyframesDefinition } from 'motion';
+import { type MotionHandle } from './animate';
+import { type MotionPreference } from './reduced-motion';
+type PresencePhase = 'enter' | 'exit';
+type PresencePreset = 'popover' | 'menu' | 'modal' | 'toast' | 'sidebar' | 'fade';
+type PresenceDefinition = PresencePreset | DOMKeyframesDefinition;
+type PresenceOptions = AnimationOptions & {
+    reducedMotion?: MotionPreference;
+};
+type PresenceLifecycleCallbacks = {
+    before?: () => void;
+    after?: () => void;
+};
+type PresenceLifecycleOptions = {
+    element: () => Element | null | undefined;
+    preset?: PresenceDefinition;
+    enter?: PresenceDefinition;
+    exit?: PresenceDefinition;
+    options?: PresenceOptions;
+    enterOptions?: PresenceOptions;
+    exitOptions?: PresenceOptions;
+    owner?: 'component' | false;
+};
+type PresenceLifecycle = {
+    readonly runId: number;
+    enter(callbacks?: PresenceLifecycleCallbacks): MotionHandle;
+    exit(callbacks?: PresenceLifecycleCallbacks): MotionHandle;
+    cancel(): void;
+    destroy(): void;
+};
+declare const animatePresence: (element: Element, phase: PresencePhase, preset?: PresenceDefinition, options?: PresenceOptions) => MotionHandle;
+declare const createPresenceLifecycle: ({ element, preset, enter, exit, options, enterOptions, exitOptions, owner, }: PresenceLifecycleOptions) => PresenceLifecycle;
+export { animatePresence, createPresenceLifecycle };
+export type { PresenceDefinition, PresenceLifecycle, PresenceLifecycleCallbacks, PresenceLifecycleOptions, PresenceOptions, PresencePhase, PresencePreset };

package/types/motion/reduced-motion.d.ts

@@ -0,0 +1,9 @@
+import type { AnimationOptions, DOMKeyframesDefinition } from 'motion';
+type MotionPreference = 'user' | 'always' | 'never';
+declare const reducedMotionQuery = "(prefers-reduced-motion: reduce)";
+declare const prefersReducedMotion: () => boolean;
+declare const shouldReduceMotion: (preference?: MotionPreference) => boolean;
+declare const withReducedMotion: <T extends AnimationOptions>(options: T, reducedOptions?: Partial<T>, preference?: MotionPreference) => T;
+declare const reduceKeyframes: (keyframes: DOMKeyframesDefinition) => DOMKeyframesDefinition;
+export { prefersReducedMotion, reducedMotionQuery, reduceKeyframes, shouldReduceMotion, withReducedMotion, };
+export type { MotionPreference };

package/types/motion/stream.d.ts

@@ -0,0 +1,18 @@
+import { type AnimateViewOptions } from './view';
+import { type MotionTarget, type ViewScope } from './targets';
+import { type MotionHandle } from './animate';
+import { type MotionPreference } from './reduced-motion';
+type StreamPatchLike = {
+    html?: string | null;
+    target?: string | null;
+    selector?: string | null;
+};
+type AnimateStreamPatchOptions = Omit<AnimateViewOptions, 'scope' | 'preset'> & {
+    scope?: ViewScope | 'target';
+    update?: () => void | Promise<void>;
+    reducedMotion?: MotionPreference;
+};
+declare const streamTargetsFromPatches: (patches: StreamPatchLike[]) => MotionTarget[];
+declare const animateStreamPatch: <AlpineInstance>(_Alpine: AlpineInstance, patchOrPatches: StreamPatchLike | StreamPatchLike[], options?: AnimateStreamPatchOptions) => MotionHandle;
+export { animateStreamPatch, streamTargetsFromPatches };
+export type { AnimateStreamPatchOptions, StreamPatchLike };

package/types/motion/targets.d.ts

@@ -0,0 +1,31 @@
+type MotionTarget = Element | string | {
+    selector: string;
+} | {
+    part: string;
+} | {
+    key: string;
+} | {
+    from: MotionTarget;
+    to: MotionTarget;
+};
+type ViewScope = Element | Document | string | Iterable<Element>;
+type ViewTargetDefinition = Element | string;
+type ResolvedViewTarget = {
+    subject: ViewTargetDefinition;
+    newSubject?: ViewTargetDefinition;
+};
+declare const MOTION_KEY_ATTR = "data-ui-motion-key";
+declare const MOTION_LAYOUT_ATTR = "data-ui-motion-layout";
+declare const MOTION_TEMP_ATTR = "data-ui-motion-temp";
+declare const MOTION_ACTIVE_ATTR = "data-ui-motion-active";
+declare const cssEscape: (value: string) => string;
+declare const keySelector: (key: string) => string;
+declare const partSelector: (part: string) => string;
+declare const resolveTargets: (scope?: ViewScope, targets?: MotionTarget | MotionTarget[] | null) => Element[];
+declare const resolveViewTargets: (scope?: ViewScope, targets?: MotionTarget | MotionTarget[] | null) => ResolvedViewTarget[];
+declare const applyViewKeys: (scope?: ViewScope, options?: {
+    key?: string;
+    layout?: boolean;
+}) => (() => void);
+export { MOTION_ACTIVE_ATTR, MOTION_KEY_ATTR, MOTION_LAYOUT_ATTR, MOTION_TEMP_ATTR, applyViewKeys, cssEscape, keySelector, partSelector, resolveTargets, resolveViewTargets, };
+export type { MotionTarget, ResolvedViewTarget, ViewScope, ViewTargetDefinition };

package/types/motion/view.d.ts

@@ -0,0 +1,22 @@
+import { type AnimationOptions, type DOMKeyframesDefinition, type ViewTransitionOptions } from 'motion';
+import { type MotionHandle } from './animate';
+import { type MotionPreference } from './reduced-motion';
+import { type MotionTarget, type ViewScope } from './targets';
+type ViewPreset = 'layout' | 'stream' | 'none';
+type AnimateViewOptions = {
+    scope?: ViewScope;
+    reducedMotion?: MotionPreference;
+    preset?: ViewPreset;
+    transition?: ViewTransitionOptions;
+    layout?: boolean | AnimationOptions;
+    newView?: DOMKeyframesDefinition;
+    oldView?: DOMKeyframesDefinition;
+    enter?: DOMKeyframesDefinition;
+    exit?: DOMKeyframesDefinition;
+    className?: string;
+    crop?: boolean;
+    group?: boolean;
+};
+declare const animateView: (update: () => void | Promise<void>, targets?: MotionTarget | MotionTarget[] | null, options?: AnimateViewOptions) => MotionHandle;
+export { animateView };
+export type { AnimateViewOptions, ViewPreset };

package/types/runtime/anchored-popover.d.ts

@@ -0,0 +1,20 @@
+type PopoverSide = 'top' | 'bottom' | 'left' | 'right';
+type PopoverAlign = 'start' | 'center' | 'end';
+type AnchoredPopoverOptions = {
+    reference: () => HTMLElement;
+    floating: () => HTMLElement;
+    position: () => PopoverSide;
+    align: () => PopoverAlign;
+    gap: () => number;
+    offset: () => number;
+    matchReferenceWidth?: boolean;
+};
+type AnchoredPopover = {
+    mounted(): boolean;
+    mount(): void;
+    unmount(): void;
+    sync(): void;
+};
+declare const createAnchoredPopover: ({ reference, floating, position: getPosition, align: getAlign, gap, offset, matchReferenceWidth, }: AnchoredPopoverOptions) => AnchoredPopover;
+export { createAnchoredPopover };
+export type { AnchoredPopover, AnchoredPopoverOptions, PopoverAlign, PopoverSide };

package/types/runtime/class-name.d.ts

@@ -0,0 +1,9 @@
+import { type ClassValue } from 'clsx';
+type ClassDictionary = Record<string, boolean | null | undefined>;
+type ClassArray = ClassValue[];
+type ClassNameOptions = {
+    values: readonly ClassValue[];
+};
+export declare const className: ({ values }: ClassNameOptions) => string;
+export declare const cx: ({ values }: ClassNameOptions) => string;
+export type { ClassArray, ClassDictionary, ClassNameOptions, ClassValue };

package/types/runtime/codecs.d.ts

@@ -0,0 +1,66 @@
+type CodecKind = 'string' | 'number' | 'boolean' | 'enum' | 'json';
+type CodecMeta<T> = {
+    type: CodecKind;
+    default: T;
+    values?: readonly string[];
+    emptyString?: 'default' | 'value';
+};
+interface CodecFn<T> {
+    (el: HTMLElement, attr: string): T;
+    readonly meta: CodecMeta<T>;
+}
+type SchemaToProps<T extends Record<string, CodecFn<unknown>>> = {
+    [K in keyof T]: ReturnType<T[K]>;
+};
+type PropState<T extends Record<string, CodecFn<unknown>>> = SchemaToProps<T> & {
+    readonly disconnect: () => void;
+};
+type DefinePropsOptions<T extends Record<string, CodecFn<unknown>>> = {
+    el: HTMLElement;
+    schema: T;
+};
+type ReactiveFn = <T>(value: T) => T;
+interface StringCodec extends CodecFn<string> {
+    trim: StringCodec;
+    lower: StringCodec;
+    upper: StringCodec;
+    kebab: StringCodec;
+    camel: StringCodec;
+    snake: StringCodec;
+    default(val: string): StringCodec;
+    emptyAsValue: StringCodec;
+    emptyAsDefault: StringCodec;
+    maxLength(n: number): StringCodec;
+    prefix(p: string): StringCodec;
+    suffix(s: string): StringCodec;
+}
+interface NumberCodec extends CodecFn<number> {
+    clamp(min: number, max: number): NumberCodec;
+    min(n: number): NumberCodec;
+    max(n: number): NumberCodec;
+    step(n: number): NumberCodec;
+    default(val: number): NumberCodec;
+}
+interface BoolCodec extends CodecFn<boolean> {
+    default(val: boolean): BoolCodec;
+}
+interface OneOfCodec<T extends string> extends CodecFn<T> {
+    default(val: T): OneOfCodec<T>;
+}
+interface JsonCodec<T> extends CodecFn<T> {
+    default(val: T): JsonCodec<T>;
+}
+interface JsonCodecFactory {
+    <T>(fallback: T): JsonCodec<T>;
+    object<T extends Record<string, unknown>>(fallback: T): JsonCodec<T>;
+    array<T>(fallback: T[]): JsonCodec<T[]>;
+}
+declare const setPropReactivity: (nextReactive: ReactiveFn) => void;
+declare const defineProps: <T extends Record<string, CodecFn<unknown>>>({ el, schema, }: DefinePropsOptions<T>) => PropState<T>;
+declare const string: StringCodec;
+declare const number: NumberCodec;
+declare const bool: BoolCodec;
+declare const json: JsonCodecFactory;
+declare const oneOf: <T extends string>(allowed: readonly T[], fallback: T) => OneOfCodec<T>;
+export { defineProps, setPropReactivity, string, number, bool, json, oneOf };
+export type { BoolCodec, CodecFn, CodecKind, CodecMeta, DefinePropsOptions, JsonCodec, JsonCodecFactory, NumberCodec, OneOfCodec, PropState, ReactiveFn, SchemaToProps, StringCodec, };

package/types/runtime/collection-navigation.d.ts

@@ -0,0 +1,33 @@
+type CollectionRoot = HTMLElement | null;
+type CollectionNavigationOptions = {
+    root: () => CollectionRoot;
+    itemSelector: string;
+    activeAttribute?: string;
+    isDisabled?: (el: HTMLElement) => boolean;
+    loop?: boolean | (() => boolean);
+};
+type CollectionItemsOptions = {
+    items?: HTMLElement[];
+};
+type CollectionElementOptions = {
+    el: HTMLElement;
+};
+type CollectionKeydownOptions = {
+    event: KeyboardEvent;
+};
+type CollectionNavigation = {
+    allItems(): HTMLElement[];
+    items(): HTMLElement[];
+    currentActiveIndex(options?: CollectionItemsOptions): number;
+    activateItem(options: CollectionElementOptions): void;
+    clearActiveItem(): void;
+    focusItem(options: CollectionElementOptions): void;
+    focusNext(): void;
+    focusPrevious(): void;
+    focusFirst(): void;
+    focusLast(): void;
+    handleKeydown(options: CollectionKeydownOptions): boolean;
+};
+declare const createCollectionNavigation: ({ root: getRoot, itemSelector, activeAttribute, isDisabled, loop, }: CollectionNavigationOptions) => CollectionNavigation;
+export { createCollectionNavigation };
+export type { CollectionElementOptions, CollectionItemsOptions, CollectionKeydownOptions, CollectionNavigation, CollectionNavigationOptions, };

package/types/runtime/confirm.d.ts

@@ -0,0 +1,18 @@
+type SubmitterElement = HTMLButtonElement | HTMLInputElement;
+type ConfirmProceed = () => void;
+type ConfirmCancel = () => void;
+type ConfirmEventDetail = {
+    form: HTMLFormElement;
+    message: string;
+    submitter: SubmitterElement | null;
+    triggeringEvent: SubmitEvent;
+    proceed: ConfirmProceed;
+    cancel: ConfirmCancel;
+};
+type ConfirmRuntimeOptions = {
+    root?: Document;
+};
+declare const registerConfirm: ({ root }?: ConfirmRuntimeOptions) => void;
+declare const unregisterConfirm: () => void;
+export { registerConfirm, unregisterConfirm };
+export type { ConfirmCancel, ConfirmEventDetail, ConfirmProceed, ConfirmRuntimeOptions };

package/types/runtime/create.d.ts

@@ -0,0 +1,8 @@
+type StyleTree = string | ReadonlyArray<StyleTree> | {
+    readonly [key: string]: StyleTree;
+};
+type CreateOptions<T extends Record<string, StyleTree>> = {
+    definition: T;
+};
+export declare const create: <const T extends Record<string, StyleTree>>({ definition }: CreateOptions<T>) => Readonly<T>;
+export type { CreateOptions, StyleTree };

package/types/runtime/dismissable-layer.d.ts

@@ -0,0 +1,8 @@
+type DismissableLayerOptions = {
+    isEnabled: () => boolean;
+    roots: () => Array<EventTarget | null | undefined>;
+    onDismiss: (event: PointerEvent) => void;
+};
+declare const addDismissableLayer: ({ isEnabled, roots, onDismiss, }: DismissableLayerOptions) => (() => void);
+export { addDismissableLayer };
+export type { DismissableLayerOptions };

package/types/runtime/dom.d.ts

@@ -0,0 +1,39 @@
+type CleanupStack = Array<() => void>;
+type DispatchOptions<T> = {
+    el: HTMLElement;
+    name: string;
+    detail?: T;
+};
+type AddListenerOptions = {
+    target: EventTarget;
+    event: string;
+    handler: EventListener;
+    cleanup?: CleanupStack;
+    options?: globalThis.AddEventListenerOptions;
+};
+type PresenceOptions = {
+    el: HTMLElement;
+    attr: string;
+    present: boolean;
+    value?: string;
+};
+type AttributeOptions = {
+    el: HTMLElement;
+    attr: string;
+    value: string;
+};
+type ElementOptions = {
+    el: HTMLElement;
+};
+type BoolOptions = {
+    value: string | undefined;
+};
+declare const asBool: ({ value }: BoolOptions) => boolean;
+declare const dispatch: <T = unknown>({ el, name, detail }: DispatchOptions<T>) => void;
+declare const addListener: ({ target, event, handler, cleanup, options, }: AddListenerOptions) => (() => void);
+declare const setPresence: ({ el, attr, present, value }: PresenceOptions) => void;
+declare const setAttribute: ({ el, attr, value }: AttributeOptions) => void;
+declare const removeAttribute: ({ el, attr }: Omit<AttributeOptions, "value">) => void;
+declare const isRtl: ({ el }: ElementOptions) => boolean;
+export { addListener, asBool, dispatch, isRtl, removeAttribute, setAttribute, setPresence };
+export type { AddListenerOptions, AttributeOptions, BoolOptions, CleanupStack, DispatchOptions, ElementOptions, PresenceOptions };

package/types/runtime/form-control.d.ts

@@ -0,0 +1,44 @@
+type ControlState = {
+    disabled?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+};
+type NativeControlState = ControlState & {
+    name?: string;
+    value?: string;
+    readonly?: boolean;
+    ariaRequired?: boolean;
+    nativeRequired?: boolean;
+};
+type HiddenInputState = {
+    name: string;
+    values: string[];
+    required?: boolean;
+    form?: string;
+    marker?: string;
+};
+type SyncControlPresenceOptions = {
+    el: HTMLElement;
+    state: ControlState;
+    value?: string;
+};
+type SyncNativeControlOptions = {
+    input: HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
+    state: NativeControlState;
+};
+type SyncRepeatedHiddenInputsOptions = {
+    container: HTMLElement;
+    state: HiddenInputState;
+    currentKey?: string;
+};
+type DispatchNativeControlChangeOptions = {
+    container: HTMLElement | null;
+    fallback: HTMLElement;
+    marker: string;
+};
+declare const syncControlPresence: ({ el, state, value, }: SyncControlPresenceOptions) => void;
+declare const syncNativeControl: ({ input, state, }: SyncNativeControlOptions) => void;
+declare const syncRepeatedHiddenInputs: ({ container, state, currentKey, }: SyncRepeatedHiddenInputsOptions) => string;
+declare const dispatchNativeControlChange: ({ container, fallback, marker, }: DispatchNativeControlChangeOptions) => void;
+export { dispatchNativeControlChange, syncControlPresence, syncNativeControl, syncRepeatedHiddenInputs, };
+export type { ControlState, DispatchNativeControlChangeOptions, HiddenInputState, NativeControlState, SyncControlPresenceOptions, SyncNativeControlOptions, SyncRepeatedHiddenInputsOptions, };