@yewdiel21/motion-kit 0.10.0 → 0.14.0

package/dist/reveal-DEvp6U6T.d.ts

@@ -0,0 +1,2381 @@
+import { I as Instance } from './types-BkS_raL8.js';
+
+/** drawer: slides in from its side (data-mk-drawer="left|right", see createDrawer). */
+type DialogVariant = 'morph' | 'liquid' | 'sheet' | 'drawer';
+type DialogPlacement = 'center' | 'anchor' | 'side';
+interface DialogLabels {
+    close?: string;
+    float?: string;
+    dock?: string;
+}
+interface DialogOptions {
+    /** morph (default), liquid, or sheet: rises from the bottom and pushes [data-mk-underlay] back. */
+    variant?: DialogVariant;
+    placement?: DialogPlacement;
+    /** placement 'anchor': the box to place it against, read on open and resize (default: the opener's). */
+    anchor?: () => DOMRect | null | undefined;
+    /** Tinted backdrop; false leaves it transparent (menus). */
+    backdrop?: boolean;
+    closeOnBackdrop?: boolean;
+    /** Drag (or wheel) down to dismiss. */
+    drag?: boolean;
+    /** A key turns on the floating window (desktop) and remembers its place. */
+    float?: string | false;
+    autoResize?: boolean;
+    /** `[data-mk-open="<id>"]` buttons open it: true uses the dialog's id; a string names another id; false: none. */
+    triggers?: boolean | string;
+    /** Modal (default) or a non-modal dialog. */
+    modal?: boolean;
+    labels?: DialogLabels;
+    /** Grow the content with the surface (default). Menus turn it off and cascade their items instead. */
+    animateContent?: boolean;
+    onOpen?: () => void;
+    /** After it closed, whatever closed it. */
+    onClose?: () => void;
+}
+interface DialogInstance extends Instance {
+    /** `origin`: the control it grows from; omitted, the focused control; null, none (scale-in). */
+    open(origin?: HTMLElement | null): void;
+    close(): void;
+    toggle(origin?: HTMLElement | null): void;
+    float(): void;
+    dock(): void;
+    readonly isOpen: boolean;
+    readonly isFloating: boolean;
+    readonly element: HTMLElement;
+}
+declare function createDialog(dialog: HTMLElement | null, options?: DialogOptions): DialogInstance;
+
+interface MenuOptions extends Omit<DialogOptions, 'placement' | 'backdrop' | 'drag' | 'autoResize' | 'animateContent'> {
+    ticket?: boolean;
+    /** Close after an option is chosen (default). */
+    closeOnSelect?: boolean;
+    onSelect?: (value: string, item: HTMLElement) => void;
+}
+interface MenuInstance extends DialogInstance {
+    readonly items: HTMLElement[];
+}
+declare function createMenu(dialog: HTMLElement | null, options?: MenuOptions): MenuInstance;
+
+interface QuantityOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: number;
+    disabled?: boolean;
+    onChange?: (value: number) => void;
+}
+interface QuantityInstance extends Instance {
+    setValue(value: number, notify?: boolean): void;
+    readonly value: number;
+}
+/** Bounded numeric control. Bite/rotation is CSS; buttons remain native. */
+declare function createQuantity(root: HTMLElement | null, options?: QuantityOptions): QuantityInstance;
+
+interface PaginationOptions {
+    totalPages?: number;
+    page?: number;
+    siblings?: number;
+    pageLabel?: (page: number) => string;
+    onChange?: (page: number) => void;
+}
+interface PaginationInstance extends Instance {
+    setPage(page: number, notify?: boolean): void;
+    setTotalPages(total: number): void;
+    readonly page: number;
+    readonly totalPages: number;
+}
+/** Renders a bounded window of pages, even when totalPages is very large. */
+declare function createPagination(root: HTMLElement | null, options?: PaginationOptions): PaginationInstance;
+
+interface HoverCardOptions {
+    openDelay?: number;
+    closeDelay?: number;
+    /** Preferred side; it flips when the viewport has no room there. */
+    placement?: 'top' | 'bottom';
+    onOpenChange?: (open: boolean) => void;
+}
+interface HoverCardInstance extends Instance {
+    open(): void;
+    close(): void;
+    /** Place the open panel again (after its content changed size). */
+    reposition(): void;
+    readonly isOpen: boolean;
+}
+/**
+ * Nonmodal preview: pointer, keyboard focus and tap all reveal the same panel.
+ * The panel stays inside the viewport: it flips to the other side when its own
+ * has no room and shifts sideways (--mk-hover-shift) away from the edges, again
+ * on scroll and resize. Opened from the keyboard it appears without the entrance.
+ */
+declare function createHoverCard(root: HTMLElement | null, options?: HoverCardOptions): HoverCardInstance;
+
+interface InputOtpOptions {
+    length?: number;
+    value?: string;
+    mask?: boolean;
+    onChange?: (value: string) => void;
+    onComplete?: (value: string) => void;
+}
+interface InputOtpInstance extends Instance {
+    setValue(value: string, notify?: boolean): void;
+    focus(): void;
+    readonly value: string;
+}
+/** One real input preserves native editing, mobile autofill and password managers. */
+declare function createInputOtp(root: HTMLElement | null, options?: InputOtpOptions): InputOtpInstance;
+
+type StudioDockView = 'menu' | 'contact' | 'reel';
+interface StudioDockState {
+    open: boolean;
+    view: StudioDockView;
+    page: number;
+}
+interface StudioDockOptions {
+    /** Seconds. Reference sheet: 1.3 s, outBack(.52). */
+    duration?: number;
+    ease?: string;
+    /** Move focus into a newly opened view. Defaults to true. */
+    focusOnOpen?: boolean;
+    /** Contain Tab within the open panel and its toggle. Defaults to true. */
+    trapFocus?: boolean;
+    onChange?: (state: StudioDockState) => void;
+}
+interface StudioDockInstance extends Instance {
+    open(view?: StudioDockView): void;
+    close(): void;
+    toggle(): void;
+    selectPage(index: number): void;
+    readonly state: StudioDockState;
+}
+/** A contained studio sheet. Markup remains useful without JavaScript; fixed positioning is CSS opt-in. */
+declare function createStudioDock(root: HTMLElement | null, options?: StudioDockOptions): StudioDockInstance;
+
+type DateInput = Date | string | number;
+/** Local midnight of a date; "2026-10-23" is read as a local day, not UTC. */
+declare function toDate(input: DateInput | null | undefined, fallback?: Date): Date;
+/** YYYY-MM-DD of the local day. */
+declare const dayKey: (date: Date) => string;
+
+type CalendarView = 'month' | 'week';
+type CalendarEventStatus = 'pending' | 'done' | 'cancelled';
+interface CalendarEvent {
+    id: string | number;
+    title: string;
+    start: DateInput;
+    end?: DateInput;
+    allDay?: boolean;
+    status?: CalendarEventStatus;
+    /** Any CSS colour for the chip. */
+    color?: string;
+}
+interface CalendarRange {
+    start: Date;
+    end: Date;
+    view: CalendarView;
+}
+interface CalendarLabels {
+    more?: (count: number) => string;
+    events?: (count: number) => string;
+    status?: Partial<Record<CalendarEventStatus, string>>;
+}
+interface CalendarOptions {
+    /** Date the calendar opens on. */
+    date?: DateInput;
+    view?: CalendarView;
+    /** 0 = Sunday … 6 = Saturday. */
+    firstDay?: number;
+    locale?: string;
+    events?: CalendarEvent[];
+    /** Chips per day in the month view before "+N". */
+    maxEvents?: number;
+    selected?: DateInput | null;
+    /** Override "today" (tests, demos in another zone). */
+    today?: DateInput;
+    labels?: CalendarLabels;
+    onSelect?: (date: Date) => void;
+    onEventClick?: (event: CalendarEvent) => void;
+    onNavigate?: (range: CalendarRange) => void;
+}
+interface CalendarInstance extends Instance {
+    next(): void;
+    prev(): void;
+    goToday(): void;
+    setDate(date: DateInput): void;
+    setView(view: CalendarView): void;
+    setEvents(events: CalendarEvent[]): void;
+    select(date: DateInput | null, notify?: boolean): void;
+    readonly date: Date;
+    readonly view: CalendarView;
+    readonly selected: Date | null;
+    readonly range: CalendarRange;
+}
+declare function createCalendar(root: HTMLElement | null, options?: CalendarOptions): CalendarInstance;
+
+type SlotSource = string[] | Record<string, string[]> | ((date: Date) => string[] | Promise<string[]>);
+interface SlotValue {
+    date: Date;
+    time: string;
+    key: string;
+    value: string;
+}
+interface SlotPickerLabels {
+    placeholder?: string;
+    empty?: string;
+    loading?: string;
+    heading?: (date: Date) => string;
+}
+interface SlotPickerOptions {
+    /** Month shown first (and the selected day when `value` is not given). */
+    date?: DateInput;
+    /** Initial value: "2026-10-23T10:30" or { date, time }. */
+    value?: string | {
+        date: DateInput;
+        time: string;
+    } | null;
+    slots?: SlotSource;
+    min?: DateInput;
+    max?: DateInput;
+    /** Weekdays never available (0 = Sunday). */
+    closedDays?: number[];
+    isDisabled?: (date: Date) => boolean;
+    firstDay?: number;
+    locale?: string;
+    labels?: SlotPickerLabels;
+    onChange?: (value: SlotValue) => void;
+    onDateChange?: (date: Date) => void;
+}
+interface SlotPickerInstance extends Instance {
+    selectDate(date: DateInput): void;
+    selectTime(time: string | null): void;
+    setSlots(slots: SlotSource): void;
+    readonly date: Date | null;
+    readonly time: string | null;
+    readonly value: string | null;
+}
+declare function createSlotPicker(root: HTMLElement | null, options?: SlotPickerOptions): SlotPickerInstance;
+
+interface TrailerOptions {
+    triggers?: boolean | string;
+    autoplay?: boolean;
+    closeOnBackdrop?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+}
+interface TrailerInstance extends Instance {
+    open(origin?: HTMLElement | null): void;
+    close(): void;
+    toggle(origin?: HTMLElement | null): void;
+    play(): Promise<boolean>;
+    pause(): void;
+    seek(seconds: number): void;
+    setVolume(volume: number): void;
+    readonly isOpen: boolean;
+}
+/** Native modal + consumer-owned video, with optional accessible custom transport controls. */
+declare function createTrailer(root: HTMLElement | null, options?: TrailerOptions): TrailerInstance;
+
+type CardBrand = 'visa' | 'mastercard' | 'amex' | 'discover' | 'unknown';
+/** Text shown on the card for each brand (no logos). */
+declare const BRAND_LABELS: Record<CardBrand, string>;
+declare function detectBrand(number: string): CardBrand;
+declare const cardLength: (brand: CardBrand) => number;
+declare const cvcLength: (brand: CardBrand) => 4 | 3;
+/** Digits with a space between groups. */
+declare function formatNumber(number: string, brand?: CardBrand): string;
+declare function luhn(number: string): boolean;
+interface Expiry {
+    month: number;
+    year: number;
+    /** MM/YY as typed so far. */
+    text: string;
+    valid: boolean;
+}
+/** MM/YY from what was typed; valid when complete and not before the current month. */
+declare function parseExpiry(text: string, now?: Date): Expiry;
+
+type CreditCardField = 'number' | 'name' | 'expiry' | 'cvc';
+interface CreditCardLabels {
+    number?: string;
+    name?: string;
+    expiry?: string;
+    cvc?: string;
+    namePlaceholder?: string;
+    invalidNumber?: string;
+    invalidExpiry?: string;
+    invalidCvc?: string;
+}
+interface CreditCardOptions {
+    labels?: CreditCardLabels;
+    /** Form names of the fields (default cc-number, cc-name, cc-exp, cc-csc). */
+    names?: Partial<Record<CreditCardField, string>>;
+    /** Tilt the card with a fine pointer (default true). */
+    tilt?: boolean;
+    onChange?: (state: {
+        brand: CardBrand;
+        complete: boolean;
+        valid: boolean;
+    }) => void;
+    onComplete?: () => void;
+}
+interface CreditCardValues {
+    number: string;
+    name: string;
+    expiry: string;
+    cvc: string;
+}
+interface CreditCardInstance extends Instance {
+    readonly values: CreditCardValues;
+    readonly brand: CardBrand;
+    readonly valid: boolean;
+    focus(field: CreditCardField): void;
+    /** Turn the card (true: the back). */
+    flip(back?: boolean): void;
+}
+declare function createCreditCard(root: HTMLElement | null, options?: CreditCardOptions): CreditCardInstance;
+
+interface CommandItem {
+    id: string;
+    label: string;
+    /** Section title (e.g. 'Páginas'). */
+    group?: string;
+    /** Extra words that also match. */
+    keywords?: string[];
+    /** Small text on the right (a shortcut, a path). */
+    hint?: string;
+    /** Navigate here when chosen (unless mk:select is cancelled). */
+    href?: string;
+    /** A short glyph shown before the label (default →). */
+    icon?: string;
+}
+interface CommandSearchOptions {
+    items?: CommandItem[];
+    placeholder?: string;
+    emptyLabel?: string;
+    /** Accessible name of the palette. */
+    label?: string;
+    /** ⌘K / Ctrl+K opens it (default true). */
+    shortcut?: boolean;
+    /** Most results shown (default 50). */
+    limit?: number;
+    onSelect?: (item: CommandItem) => void;
+    onOpenChange?: (open: boolean) => void;
+}
+interface CommandSearchInstance extends Instance {
+    /** `origin`: the control it grows from; omitted, the clicked or on-screen trigger; null, none (scale-in). */
+    open(origin?: HTMLElement | null): void;
+    close(): void;
+    setItems(items: CommandItem[]): void;
+    readonly isOpen: boolean;
+}
+declare function createCommandSearch(root: HTMLElement | null, options?: CommandSearchOptions): CommandSearchInstance;
+
+interface HoldConfirmOptions {
+    /** Hold time in ms (default 1200). */
+    duration?: number;
+    /** Back to the start after confirming, in ms (default 1800; 0 keeps it confirmed). */
+    resetAfter?: number;
+    holdingLabel?: string;
+    doneLabel?: string;
+    hint?: string;
+    disabled?: boolean;
+    onConfirm?: () => void;
+}
+interface HoldConfirmInstance extends Instance {
+    reset(): void;
+    readonly confirmed: boolean;
+}
+declare function createHoldConfirm(root: HTMLElement | null, options?: HoldConfirmOptions): HoldConfirmInstance;
+
+interface ImagePreviewOptions {
+    labels?: {
+        close?: string;
+        prev?: string;
+        next?: string;
+        dialog?: string;
+    };
+    /** Loop from the last picture to the first (default true). */
+    loop?: boolean;
+    onChange?: (index: number) => void;
+    onOpenChange?: (open: boolean) => void;
+}
+interface ImagePreviewInstance extends Instance {
+    open(index?: number): void;
+    close(): void;
+    next(): void;
+    prev(): void;
+    readonly isOpen: boolean;
+    readonly index: number;
+}
+declare function createImagePreview(root: HTMLElement | null, options?: ImagePreviewOptions): ImagePreviewInstance;
+
+interface NotificationBellOptions {
+    count?: number;
+    /** Accessible name before the count (default 'Notificaciones'). */
+    label?: string;
+    /** How long a message stays, in ms (default 3200). */
+    messageDuration?: number;
+    /** Above this the badge reads n+ (default 99). */
+    max?: number;
+    onOpen?: () => void;
+}
+interface NotificationBellInstance extends Instance {
+    /** Ring with a new notification (and show `message`, as text). */
+    notify(message?: string): void;
+    setCount(count: number): void;
+    clear(): void;
+    readonly count: number;
+}
+declare function createNotificationBell(root: HTMLElement | null, options?: NotificationBellOptions): NotificationBellInstance;
+
+interface PasswordChecks {
+    length: boolean;
+    lower: boolean;
+    upper: boolean;
+    number: boolean;
+    symbol: boolean;
+}
+interface PasswordScore {
+    score: 0 | 1 | 2 | 3 | 4;
+    label: string;
+    checks: PasswordChecks;
+}
+declare const STRENGTH_LABELS: readonly ["Muy débil", "Débil", "Aceptable", "Fuerte", "Muy fuerte"];
+declare function scorePassword(value: string, minLength?: number): PasswordScore;
+
+interface PasswordStrengthOptions {
+    minLength?: number;
+    /** Replace the built-in scoring. */
+    score?: (value: string) => PasswordScore;
+    /** Below this score the field reports itself invalid (setCustomValidity). */
+    requireScore?: number;
+    labels?: {
+        show?: string;
+        hide?: string;
+        invalid?: string;
+        checks?: Partial<Record<keyof PasswordChecks, string>>;
+    };
+    onChange?: (result: PasswordScore) => void;
+}
+interface PasswordStrengthInstance extends Instance {
+    readonly score: number;
+    readonly value: string;
+}
+declare function createPasswordStrength(root: HTMLElement | null, options?: PasswordStrengthOptions): PasswordStrengthInstance;
+
+interface ScratchCardOptions {
+    /** Share of the cover to scratch before it reveals itself (default .5). */
+    threshold?: number;
+    /** Brush radius in px (default 22). */
+    brush?: number;
+    coverLabel?: string;
+    revealLabel?: string;
+    revealedLabel?: string;
+    /** Confetti on reveal (default true). */
+    celebrate?: boolean;
+    onProgress?: (progress: number) => void;
+    onReveal?: () => void;
+}
+interface ScratchCardInstance extends Instance {
+    reveal(): void;
+    reset(): void;
+    readonly revealed: boolean;
+    readonly progress: number;
+}
+declare function createScratchCard(root: HTMLElement | null, options?: ScratchCardOptions): ScratchCardInstance;
+
+interface StarRatingOptions {
+    max?: number;
+    value?: number;
+    /** Form name (default 'rating'). */
+    name?: string;
+    /** Accessible name of the group (default 'Valoración'). */
+    label?: string;
+    /** One text per star, shown and read for the chosen value. */
+    labels?: string[];
+    readonly?: boolean;
+    allowClear?: boolean;
+    disabled?: boolean;
+    onChange?: (value: number) => void;
+}
+interface StarRatingInstance extends Instance {
+    setValue(value: number, notify?: boolean): void;
+    readonly value: number;
+}
+declare function createStarRating(root: HTMLElement | null, options?: StarRatingOptions): StarRatingInstance;
+
+type AttachmentStatus = 'idle' | 'uploading' | 'complete' | 'error';
+type AttachmentRejectCode = 'type' | 'size' | 'count';
+interface AttachmentFile {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    /** The picked File (absent for files described by metadata only). */
+    file?: File;
+    /** 0–100 once the app reports it. */
+    progress?: number;
+    status: AttachmentStatus;
+    /** Object URL of an image preview, or a URL supplied with initialFiles. */
+    preview?: string;
+}
+interface AttachmentRejection {
+    file: File;
+    code: AttachmentRejectCode;
+    message: string;
+}
+interface AttachmentLabels {
+    choose?: string;
+    drop?: string;
+    remove?: string;
+    list?: string;
+    uploading?: string;
+    complete?: string;
+    error?: string;
+    added?: (count: number) => string;
+    removed?: (name: string) => string;
+    rejected?: (rejection: {
+        name: string;
+        code: AttachmentRejectCode;
+        limit: string;
+    }) => string;
+}
+interface AttachmentOptions {
+    /** Like input[accept]: extensions (.pdf), MIME types (image/png) and wildcards (image/*). */
+    accept?: string;
+    multiple?: boolean;
+    /** Most files kept (multiple only). */
+    maxFiles?: number;
+    /** Largest file, in bytes. */
+    maxSize?: number;
+    disabled?: boolean;
+    /** Form name of the file input (it carries the kept files where the browser allows). */
+    name?: string;
+    /** Files shown from the start (e.g. already uploaded). */
+    initialFiles?: Array<Partial<AttachmentFile> & {
+        name: string;
+    }>;
+    /** Visible hint under the drop text (default: the limits). */
+    hint?: string;
+    labels?: AttachmentLabels;
+    onFiles?: (added: AttachmentFile[], files: AttachmentFile[]) => void;
+    onRemove?: (removed: AttachmentFile, files: AttachmentFile[]) => void;
+    onReject?: (rejections: AttachmentRejection[]) => void;
+}
+interface AttachmentInstance extends Instance {
+    /** Validate and add files; returns the accepted ones. */
+    addFiles(files: Iterable<File> | ArrayLike<File>): AttachmentFile[];
+    remove(id: string): void;
+    /** Report upload progress (0–100) and, optionally, the status. */
+    setProgress(id: string, value: number, status?: AttachmentStatus): void;
+    clear(): void;
+    readonly files: AttachmentFile[];
+}
+/** 1 KB = 1024 B; one decimal under 10. */
+declare function formatBytes(bytes: number): string;
+/** Readable accept list: image/* → imágenes, .pdf → PDF, application/zip → ZIP. */
+declare function describeAccept(accept: string | undefined): string;
+/** Does a file match an accept list (extensions, MIME types, type/*)? */
+declare function acceptsFile(file: {
+    name: string;
+    type: string;
+}, accept: string | undefined): boolean;
+declare function createAttachment(root: HTMLElement | null, options?: AttachmentOptions): AttachmentInstance;
+
+type SkeletonShape = 'text' | 'avatar' | 'image' | 'card';
+type SkeletonAnimation = 'pulse' | 'shimmer' | 'none';
+interface SkeletonOptions {
+    loading?: boolean;
+    animation?: SkeletonAnimation;
+    /** Placeholder made when the markup has none. */
+    shape?: SkeletonShape;
+    /** Text lines of a generated text placeholder (default 3). */
+    lines?: number;
+    /** Announced while loading (default 'Cargando'). */
+    label?: string;
+}
+interface SkeletonInstance extends Instance {
+    setLoading(loading: boolean): void;
+    readonly loading: boolean;
+}
+/** Bones of each shape: block (image), circle (avatar), line (text). */
+declare function skeletonBones(shape: SkeletonShape, lines?: number): Array<'block' | 'circle' | 'line' | 'short'>;
+declare function createSkeleton(root: HTMLElement | null, options?: SkeletonOptions): SkeletonInstance;
+
+type QuestionnaireAnswers = Record<string, string | string[]>;
+interface QuestionnaireLabels {
+    required?: string;
+    choice?: string;
+}
+interface QuestionnaireOptions {
+    index?: number;
+    labels?: QuestionnaireLabels;
+    onChange?: (index: number, answers: QuestionnaireAnswers) => void;
+    onComplete?: (answers: QuestionnaireAnswers) => void;
+}
+interface QuestionnaireInstance extends Instance {
+    /** Validate the current step and go on (or complete on the last one). */
+    next(): Promise<boolean>;
+    prev(): Promise<void>;
+    /** Native form reset: clears answers, errors and completion. */
+    reset(): void;
+    readonly answers: QuestionnaireAnswers;
+    readonly index: number;
+    readonly count: number;
+    readonly complete: boolean;
+}
+/** Answers of a form keyed by field name: checkboxes and multi-selects give arrays. */
+declare function readAnswers(form: HTMLElement): QuestionnaireAnswers;
+declare function createQuestionnaire(root: HTMLElement | null, options?: QuestionnaireOptions): QuestionnaireInstance;
+
+interface CodeBlockOptions {
+    /** The code; omitted, the text already in <code> is used (and read at copy time). */
+    code?: string;
+    language?: string;
+    title?: string;
+    lineNumbers?: boolean;
+    /** Colour the syntax (default: when the language is supported). */
+    highlight?: boolean;
+    /** 1-based lines to mark. */
+    highlightLines?: number[];
+    copyLabel?: string;
+    copiedLabel?: string;
+    errorLabel?: string;
+    onCopy?: (ok: boolean) => void;
+}
+interface CodeBlockInstance extends Instance {
+    setCode(code: string): void;
+    /** Copy the code; resolves true when the clipboard took it. */
+    copy(): Promise<boolean>;
+    readonly code: string;
+}
+/** Line count of a code string (a final newline does not open a line). */
+declare const codeLines: (code: string) => number;
+declare function createCodeBlock(root: HTMLElement | null, options?: CodeBlockOptions): CodeBlockInstance;
+
+interface ContextMenuOptions extends Omit<MenuOptions, 'triggers' | 'anchor'> {
+    /** Replace the browser menu on inputs and editable text too. */
+    overrideEditable?: boolean;
+    /** Touch long press that opens it, in ms (0: off). Default 550. */
+    longPress?: number;
+    onOpenChange?: (open: boolean) => void;
+}
+interface ContextMenuInstance extends Instance {
+    /** Open at viewport coordinates; focus returns to `origin` (default: the focused element). */
+    openAt(x: number, y: number, origin?: HTMLElement | null): void;
+    /** Open beside `origin` (default: the focused element in the trigger, else the trigger). */
+    open(origin?: HTMLElement | null): void;
+    close(): void;
+    readonly isOpen: boolean;
+    readonly menu: MenuInstance | null;
+}
+declare function createContextMenu(root: HTMLElement | null, options?: ContextMenuOptions): ContextMenuInstance;
+
+/** card: image on top (default); row: thumbnail beside the text; hover: a link that previews the card. */
+type LinkPreviewVariant = 'card' | 'row' | 'hover';
+interface LinkPreviewOptions extends Pick<HoverCardOptions, 'openDelay' | 'closeDelay' | 'placement' | 'onOpenChange'> {
+    url?: string;
+    title?: string;
+    description?: string;
+    /** Thumbnail URL (http(s), relative, data:image or blob). */
+    image?: string;
+    imageAlt?: string;
+    siteName?: string;
+    variant?: LinkPreviewVariant;
+    /** Text of the hover variant's link (default: the title). */
+    label?: string;
+    /** '_blank' opens a new tab (with rel="noopener noreferrer"). */
+    target?: string;
+}
+interface LinkPreviewInstance extends Instance {
+    /** The link actually used (null when the URL was refused). */
+    readonly href: string | null;
+    readonly hoverCard: HoverCardInstance | null;
+}
+/** http(s) or relative links; anything else (javascript:, data:, vbscript:…) is null. */
+declare function safeHref(url: string | null | undefined): string | null;
+/** Image sources: http(s), relative, blob: and data:image/… */
+declare function safeImage(url: string | null | undefined): string | null;
+/** Host without www. of an absolute link; relative links have none (same on server and client). */
+declare function linkDomain(href: string | null): string;
+declare function createLinkPreview(root: HTMLElement | null, options?: LinkPreviewOptions): LinkPreviewInstance;
+
+type ProgressVariant = 'linear' | 'ring';
+interface ProgressOptions {
+    /** Current value; null is indeterminate. Default: min. */
+    value?: number | null;
+    min?: number;
+    max?: number;
+    label?: string;
+    variant?: ProgressVariant;
+    /** Write the percentage beside the bar (inside the ring). */
+    showValue?: boolean;
+    /** Text for the value (also aria-valuetext). Default: rounded percentage. */
+    formatValue?: (value: number, ratio: number) => string;
+    /** Glide duration in seconds (default .7). */
+    duration?: number;
+}
+interface ProgressInstance extends Instance {
+    setValue(value: number | null): void;
+    readonly value: number | null;
+}
+declare function createProgress(root: HTMLElement | null, options?: ProgressOptions): ProgressInstance;
+
+type RangeValue = number | [number, number];
+interface RangeSliderOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: RangeValue;
+    disabled?: boolean;
+    /** Form name; an interval submits name[0] and name[1]. */
+    name?: string;
+    /** Accessible name of the input(s). */
+    label?: string;
+    /** Text for the output and aria-valuetext. */
+    formatValue?: (value: number) => string;
+    onInput?: (value: RangeValue) => void;
+    onChange?: (value: RangeValue) => void;
+}
+interface RangeSliderInstance extends Instance {
+    setValue(value: RangeValue, notify?: boolean): void;
+    readonly value: RangeValue;
+}
+declare function createRangeSlider(root: HTMLElement | null, options?: RangeSliderOptions): RangeSliderInstance;
+
+type ChartType = 'line' | 'area' | 'bar';
+interface ChartPoint {
+    label: string;
+    value: number | null;
+}
+interface ChartSeries {
+    name: string;
+    /** One value per label; null is a gap (no data). */
+    values: Array<number | null>;
+    /** Any CSS colour; default: monochrome for one series, else the --mk-chart-N slot. */
+    color?: string;
+    /** Lines: an SVG dash pattern, e.g. '5 5' (a pace or goal) or '1 6' (a projection). */
+    dash?: string;
+}
+interface ChartOptions {
+    type?: ChartType;
+    labels?: string[];
+    series?: ChartSeries[];
+    /** One series as label/value pairs (instead of labels + series). */
+    points?: ChartPoint[];
+    /** Bars only: stack the series. */
+    stacked?: boolean;
+    formatValue?: (value: number) => string;
+    /** Accessible name (and table caption). */
+    label?: string;
+    /** Plot height in px (default 240). */
+    height?: number;
+    emptyLabel?: string;
+    /** Legend (default: two or more series). */
+    legend?: boolean;
+    /** Value labels and hairlines on the y axis (default false: the baseline only). */
+    axis?: boolean;
+    /** Lines: the last value of the first series in a pill at its end (default true). */
+    endLabel?: boolean;
+    /** The built-in tooltip card (default true); false keeps the guide and markers for chart-tooltip. */
+    tooltip?: boolean;
+    onSelect?: (index: number | null) => void;
+}
+interface ChartInstance extends Instance {
+    /** Merge new options and draw again (keeps the selection when it still exists). */
+    update(options: ChartOptions): void;
+    select(index: number | null): void;
+    readonly selected: number | null;
+}
+declare function createChart(root: HTMLElement | null, initial?: ChartOptions): ChartInstance;
+
+interface Hsva {
+    /** 0–360. */
+    h: number;
+    /** 0–100. */
+    s: number;
+    /** 0–100. */
+    v: number;
+    /** 0–1. */
+    a: number;
+}
+interface Rgba {
+    /** 0–255. */
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+interface Hsla {
+    h: number;
+    /** 0–100. */
+    s: number;
+    l: number;
+    a: number;
+}
+type ColorFormat = 'hex' | 'rgb' | 'hsl';
+type ColorChannel = 'hue' | 'saturation' | 'brightness' | 'lightness' | 'red' | 'green' | 'blue' | 'alpha';
+declare const CHANNEL_LABELS: Record<ColorChannel, string>;
+/** HSVA → RGBA (channels 0–255, unrounded). */
+declare function hsvToRgb({ h, s, v, a }: Hsva): Rgba;
+/** RGBA → HSVA; a grey keeps `hue` (and black keeps `saturation`) when given. */
+declare function rgbToHsv({ r, g, b, a }: Rgba, hue?: number, saturation?: number): Hsva;
+/**
+ * Any colour the components accept, as HSVA; null when the text is not one.
+ * `hue` is kept for greys (no hue of their own).
+ */
+declare function parseColor(input: string | null | undefined, hue?: number): Hsva | null;
+/** A colour option (text or HSVA) as HSVA; `fallback` (default red) when it cannot be read. */
+declare function toHsva(input: string | Hsva | null | undefined, fallback?: Hsva): Hsva;
+/** #rrggbb, or #rrggbbaa when translucent. */
+declare function toHex(color: Hsva): string;
+/** The colour as CSS text: hex, "rgb(255 136 0 / 0.5)" or "hsl(32 100% 50%)". */
+declare function formatColor(color: Hsva, format?: ColorFormat): string;
+/** Relative luminance (WCAG), 0–1, ignoring alpha. */
+declare function luminance(color: Hsva): number;
+/** One channel's value in its own range (CHANNEL_RANGE). */
+declare function getChannel(color: Hsva, channel: ColorChannel): number;
+/** A copy with one channel changed (clamped to its range); the hue survives greys. */
+declare function setChannel(color: Hsva, channel: ColorChannel, value: number): Hsva;
+/** What a channel's value reads as: "210°", "64 %", "136". */
+declare function channelText(channel: ColorChannel, value: number, format?: Intl.NumberFormat): string;
+
+interface ColorSliderOptions {
+    /** Channel this slider edits (default 'hue'). */
+    channel?: ColorChannel;
+    /** Any CSS colour parseColor reads, or HSVA (default 'hsl(0 100% 50%)'). */
+    value?: string | Hsva;
+    /** Accessible name (default: the channel's Spanish name). */
+    label?: string;
+    orientation?: 'horizontal' | 'vertical';
+    /** Default 1 (alpha .01). */
+    step?: number;
+    /** Shows the value ("210°", "64 %") in an <output>. */
+    showValue?: boolean;
+    /** Form name: a hidden input submits the hex. */
+    name?: string;
+    disabled?: boolean;
+    /** Every move. */
+    onInput?: (value: string, color: Hsva) => void;
+    /** Committed (release, key). */
+    onChange?: (value: string, color: Hsva) => void;
+}
+interface ColorSliderInstance extends Instance {
+    /** Another control changed the colour; `notify` false keeps callbacks quiet. */
+    setColor(color: string | Hsva, notify?: boolean): void;
+    /** Hex (#rrggbb, #rrggbbaa when translucent). */
+    readonly value: string;
+    readonly color: Hsva;
+}
+declare function createColorSlider(root: HTMLElement | null, options?: ColorSliderOptions): ColorSliderInstance;
+
+interface ColorAreaOptions {
+    value?: string | Hsva;
+    /** Accessible name of the group (default 'Color'). */
+    label?: string;
+    /** Default 1. */
+    step?: number;
+    name?: string;
+    disabled?: boolean;
+    onInput?: (value: string, color: Hsva) => void;
+    onChange?: (value: string, color: Hsva) => void;
+}
+interface ColorAreaInstance extends Instance {
+    setColor(color: string | Hsva, notify?: boolean): void;
+    readonly value: string;
+    readonly color: Hsva;
+}
+declare function createColorArea(root: HTMLElement | null, options?: ColorAreaOptions): ColorAreaInstance;
+
+interface ColorFieldOptions {
+    value?: string | Hsva;
+    format?: ColorFormat;
+    /** Keep transparency (default false: committed colours are opaque). */
+    alpha?: boolean;
+    /** aria-label when the input has no label of its own (default 'Color'). */
+    label?: string;
+    name?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    onChange?: (value: string, color: Hsva) => void;
+}
+interface ColorFieldInstance extends Instance {
+    setColor(color: string | Hsva, notify?: boolean): void;
+    readonly value: string;
+    readonly color: Hsva;
+}
+declare function createColorField(root: HTMLElement | null, options?: ColorFieldOptions): ColorFieldInstance;
+
+interface ColorPickerOptions {
+    value?: string | Hsva;
+    alpha?: boolean;
+    format?: ColorFormat;
+    swatches?: string[];
+    /** Accessible name; the trigger reads "<label>: <hex>". */
+    label?: string;
+    name?: string;
+    disabled?: boolean;
+    /** The panel in place, without a button or popover. */
+    inline?: boolean;
+    /** Eyedropper button where the browser has the EyeDropper API (default true). */
+    eyedropper?: boolean;
+    onInput?: (value: string, color: Hsva) => void;
+    onChange?: (value: string, color: Hsva) => void;
+}
+interface ColorPickerInstance extends Instance {
+    open(): void;
+    close(): void;
+    setColor(color: string | Hsva, notify?: boolean): void;
+    readonly value: string;
+    readonly color: Hsva;
+    readonly isOpen: boolean;
+}
+declare function createColorPicker(root: HTMLElement | null, options?: ColorPickerOptions): ColorPickerInstance;
+
+interface TimeFieldOptions {
+    /** 'HH:MM' or 'HH:MM:SS' (24 h). */
+    value?: string | null;
+    locale?: string;
+    /** 12 or 24; default: the locale's. */
+    hourCycle?: 12 | 24;
+    seconds?: boolean;
+    /** Arrow step of the minutes (and seconds). */
+    minuteStep?: number;
+    min?: string;
+    max?: string;
+    /** Accessible name of the group (default 'Hora'). */
+    label?: string;
+    /** Hidden input with the 24 h text. */
+    name?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    onChange?: (value: string | null) => void;
+}
+interface TimeFieldInstance extends Instance {
+    setValue(value: string | null, animate?: boolean): void;
+    focus(): void;
+    readonly value: string | null;
+}
+declare function createTimeField(root: HTMLElement | null, options?: TimeFieldOptions): TimeFieldInstance;
+
+interface DateRange {
+    start: Date;
+    end: Date;
+}
+/** An ordered range from {start, end} (Dates or 'YYYY-MM-DD'); null when either end is missing or unreadable. */
+declare function toRange(value: {
+    start?: DateInput | null;
+    end?: DateInput | null;
+} | null | undefined): DateRange | null;
+declare const rangeKeys: (range: DateRange) => {
+    start: string;
+    end: string;
+};
+/** Days from start to end, both included. */
+declare const rangeLength: (range: DateRange) => number;
+
+interface RangeCalendarOptions {
+    value?: {
+        start: DateInput;
+        end: DateInput;
+    } | null;
+    /** First visible month (default: the value's start, else today). */
+    month?: DateInput;
+    visibleMonths?: 1 | 2;
+    /** 0 = Sunday … 6 = Saturday (default 1, Monday). */
+    firstDay?: number;
+    min?: DateInput | null;
+    max?: DateInput | null;
+    /** 'YYYY-MM-DD' keys or a test. */
+    unavailable?: string[] | ((day: Date) => boolean);
+    locale?: string;
+    /** Override "today" (demos, tests). */
+    today?: DateInput;
+    labels?: {
+        prev?: string;
+        next?: string;
+    };
+    /** 'range' (default): two clicks; 'single': one click picks a day (date-time-picker). */
+    selection?: 'range' | 'single';
+    onChange?: (range: DateRange) => void;
+}
+interface RangeCalendarInstance extends Instance {
+    setValue(range: {
+        start: DateInput;
+        end: DateInput;
+    } | null, animate?: boolean): void;
+    next(): void;
+    prev(): void;
+    /** Move the focus to `day`, changing month if needed (`animate` false: no slide). */
+    focusDay(day: DateInput, animate?: boolean): void;
+    readonly value: DateRange | null;
+    readonly month: Date;
+}
+/** Seconds a finished range of `days` takes to settle: its band draws in while its end day pops (.3 s). */
+declare const bandDuration: (days: number) => number;
+declare function createRangeCalendar(root: HTMLElement | null, options?: RangeCalendarOptions): RangeCalendarInstance;
+
+interface DateRangePreset {
+    label: string;
+    start: DateInput;
+    end: DateInput;
+}
+interface DateRangePickerOptions {
+    value?: {
+        start: DateInput;
+        end: DateInput;
+    } | null;
+    min?: DateInput | null;
+    max?: DateInput | null;
+    unavailable?: string[] | ((day: Date) => boolean);
+    firstDay?: number;
+    locale?: string;
+    today?: DateInput;
+    /** Accessible name of the field (default 'Fechas'). */
+    label?: string;
+    /** Hidden inputs name[start] and name[end] (YYYY-MM-DD). */
+    name?: string;
+    presets?: DateRangePreset[];
+    disabled?: boolean;
+    onChange?: (range: DateRange | null) => void;
+}
+interface DateRangePickerInstance extends Instance {
+    open(): void;
+    close(): void;
+    setValue(range: {
+        start: DateInput;
+        end: DateInput;
+    } | null): void;
+    readonly value: DateRange | null;
+    readonly isOpen: boolean;
+}
+declare function createDateRangePicker(root: HTMLElement | null, options?: DateRangePickerOptions): DateRangePickerInstance;
+
+type Side = 'top' | 'bottom' | 'left' | 'right';
+type Placement = Side | 'auto';
+interface Box {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+interface PlaceOptions {
+    placement?: Placement;
+    /** Space between anchor and box (default 8). */
+    gap?: number;
+    /** Distance kept from the viewport edges (default 8). */
+    edge?: number;
+    /** Along the edge: centred on the anchor (default) or flush with its start or end. */
+    align?: 'center' | 'start' | 'end';
+    /** The arrow stays this far from the box's corners (default 12). */
+    arrowPad?: number;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+}
+interface Placed {
+    side: Side;
+    /** Viewport coordinates of the box's top-left corner. */
+    x: number;
+    y: number;
+    /** Arrow position along the box's edge facing the anchor, in px from its start. */
+    arrow: number;
+}
+declare function place(anchor: Box, size: {
+    width: number;
+    height: number;
+}, options?: PlaceOptions): Placed;
+
+interface TooltipOptions {
+    /** Text of the bubble (default: the trigger's title, which is removed so the browser's own does not show). */
+    content?: string;
+    /** Preferred side (default 'top'); 'auto' takes the roomiest. */
+    placement?: Placement;
+    /** Hover delay in ms (default 400). Focus shows it at once. */
+    openDelay?: number;
+    /** Delay before hiding when the pointer leaves, in ms (default 100). */
+    closeDelay?: number;
+    /** The pointer can move onto the bubble (links, selectable text). */
+    interactive?: boolean;
+    /** Arrow pointing at the trigger (default true). */
+    arrow?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface TooltipInstance extends Instance {
+    open(): void;
+    close(): void;
+    /** New text; an open tooltip cross-fades to it. Empty text hides it. */
+    setContent(text: string): void;
+    readonly isOpen: boolean;
+}
+declare function createTooltip(root: HTMLElement | null, options?: TooltipOptions): TooltipInstance;
+
+interface PopoverOptions {
+    /** Accessible name of the panel (default: the trigger's text). */
+    label?: string;
+    onOpenChange?: (open: boolean) => void;
+}
+interface PopoverInstance extends Instance {
+    open(): void;
+    close(): void;
+    toggle(): void;
+    readonly isOpen: boolean;
+    /** The panel (a <dialog>). */
+    readonly panel: HTMLElement | null;
+}
+declare function createPopover(root: HTMLElement | null, options?: PopoverOptions): PopoverInstance;
+
+type LoadingState = 'idle' | 'loading' | 'success' | 'error';
+interface LoadingButtonOptions {
+    /** Runs on click; its promise drives the states (resolve → success, reject → error). */
+    action?: () => unknown;
+    /** Texts for the states (announced; shown beside the icon when not compact). */
+    labels?: {
+        loading?: string;
+        success?: string;
+        error?: string;
+    };
+    /** Icon only while working (default true). */
+    compact?: boolean;
+    /** ms in success or error before going back to the label (default 1800; 0 stays). */
+    resetAfter?: number;
+    onStateChange?: (state: LoadingState) => void;
+}
+interface LoadingButtonInstance extends Instance {
+    setState(state: LoadingState): void;
+    /** Runs `action` (or the option) and walks the states; resolves true on success. */
+    run(action?: () => unknown): Promise<boolean>;
+    readonly state: LoadingState;
+}
+declare function createLoadingButton(root: HTMLElement | null, options?: LoadingButtonOptions): LoadingButtonInstance;
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+}
+interface BreadcrumbOptions {
+    /** The path; without it, the authored <ol> or <a>/<span> children are read. */
+    items?: BreadcrumbItem[];
+    /** Accessible name of the navigation (default 'Ruta de navegación'). */
+    label?: string;
+    /** 'auto' (default) folds the middle when it does not fit; a number keeps at most that many items. */
+    maxItems?: number | 'auto';
+    /** Called before following a link; event.preventDefault() keeps the browser where it is (SPA routing). */
+    onNavigate?: (item: BreadcrumbItem, index: number, event: Event) => void;
+}
+interface BreadcrumbInstance extends Instance {
+    setItems(items: BreadcrumbItem[]): void;
+    readonly items: BreadcrumbItem[];
+}
+declare function createBreadcrumb(root: HTMLElement | null, options?: BreadcrumbOptions): BreadcrumbInstance;
+
+type EmptyIllustration = 'inbox' | 'search' | 'folder' | 'error' | 'success' | 'none';
+interface EmptyAction {
+    id: string;
+    label: string;
+    /** primary (default for the first) or secondary. */
+    variant?: 'primary' | 'secondary';
+    /** A link instead of a button. */
+    href?: string;
+}
+interface EmptyStateOptions {
+    illustration?: EmptyIllustration;
+    title?: string;
+    description?: string;
+    actions?: EmptyAction[];
+    /** The illustration's idle motion (default true). */
+    loop?: boolean;
+    onAction?: (id: string, event: MouseEvent) => void;
+}
+interface EmptyStateInstance extends Instance {
+    update(next: Pick<EmptyStateOptions, 'illustration' | 'title' | 'description' | 'actions'>): void;
+}
+declare function createEmptyState(root: HTMLElement | null, options?: EmptyStateOptions): EmptyStateInstance;
+
+interface StatCardOptions {
+    label?: string;
+    value?: number;
+    /** The value it is compared with (the previous period). */
+    previous?: number;
+    /** Intl.NumberFormat options (e.g. { style: 'currency', currency: 'MXN' }) or a formatter. */
+    format?: Intl.NumberFormatOptions | ((value: number) => string);
+    /** Locale for the numbers (default: the page's language). */
+    locale?: string;
+    /** Which way is good (default 'up'; 'down' for costs, churn, latency). */
+    positive?: 'up' | 'down';
+    /** What the change compares with (default 'vs. periodo anterior'). */
+    comparison?: string;
+    /** Values for the sparkline (two or more). */
+    series?: number[];
+    /** A goal: a bar shows how far the value is. */
+    target?: number;
+    /** Count when it comes into view (default true); false shows the figure at once. */
+    countOnView?: boolean;
+}
+interface StatCardInstance extends Instance {
+    update(next: Omit<StatCardOptions, 'countOnView' | 'locale'>): void;
+}
+declare function createStatCard(root: HTMLElement | null, initial?: StatCardOptions): StatCardInstance;
+
+interface ChartTooltipSeries {
+    name: string;
+    values: Array<number | null>;
+    /** Any CSS colour (default: the --mk-chart-N slot). */
+    color?: string;
+}
+interface ChartTooltipOptions {
+    /** Standalone: the x labels, one per point. */
+    labels?: string[];
+    series?: ChartTooltipSeries[];
+    /** Standalone: points edge to edge (lines, default) or at slot centres (bars). */
+    align?: 'edge' | 'center';
+    /** Standalone: the plot inside the root, in px from each side (default 0). */
+    inset?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    /** Standalone: the y scale; with it a marker sits on each series. */
+    min?: number;
+    max?: number;
+    formatValue?: (value: number) => string;
+    /** The change from the previous point (default true). */
+    delta?: boolean;
+    /** Each row's share of the total (default false). */
+    share?: boolean;
+    /** A total row (default: two or more series). */
+    total?: boolean;
+    /** Rows by value, largest first (default false). */
+    sort?: boolean;
+    /** A click pins the card (default true). */
+    pin?: boolean;
+    /** Standalone: accessible name of the focusable plot. */
+    label?: string;
+    onIndexChange?: (index: number | null) => void;
+}
+interface ChartTooltipInstance extends Instance {
+    show(index: number): void;
+    hide(): void;
+    update(options: ChartTooltipOptions): void;
+    readonly index: number | null;
+    readonly pinned: boolean;
+}
+declare function createChartTooltip(root: HTMLElement | null, initial?: ChartTooltipOptions): ChartTooltipInstance;
+
+interface MultiSelectOption {
+    value: string;
+    label: string;
+    group?: string;
+    hint?: string;
+    disabled?: boolean;
+}
+interface MultiSelectOptions {
+    /** The options; without them, an authored <select multiple> gives them. */
+    options?: MultiSelectOption[];
+    value?: string[];
+    /** Search placeholder (default 'Buscar…'). */
+    placeholder?: string;
+    /** Accessible name (default: the authored <label>, else 'Selección'). */
+    label?: string;
+    /** Hidden inputs name[] (when there is no authored select). */
+    name?: string;
+    /** At most this many choices. */
+    max?: number;
+    /** Close the list after each choice (default false). */
+    closeOnSelect?: boolean;
+    disabled?: boolean;
+    onChange?: (values: string[]) => void;
+}
+interface MultiSelectInstance extends Instance {
+    setValue(values: string[], notify?: boolean): void;
+    setOptions(options: MultiSelectOption[]): void;
+    open(): void;
+    close(): void;
+    readonly value: string[];
+}
+declare function createMultiSelect(root: HTMLElement | null, settings?: MultiSelectOptions): MultiSelectInstance;
+
+interface TagInputOptions {
+    value?: string[];
+    /** Offered while typing (fuzzy, accents ignored). */
+    suggestions?: string[];
+    placeholder?: string;
+    /** Accessible name (default: the authored <label>, else 'Etiquetas'). */
+    label?: string;
+    /** Hidden inputs name[] for forms. */
+    name?: string;
+    max?: number;
+    /** Only tags from the suggestions. */
+    restrict?: boolean;
+    allowDuplicates?: boolean;
+    /** Return a message to refuse a tag. */
+    validate?: (tag: string, tags: string[]) => string | null | undefined | void;
+    /** Clean a tag before adding it (default: trim and collapse spaces). */
+    transform?: (tag: string) => string;
+    disabled?: boolean;
+    onChange?: (tags: string[]) => void;
+}
+interface TagInputInstance extends Instance {
+    setValue(tags: string[], notify?: boolean): void;
+    /** Add a tag as if typed; false when refused. */
+    add(tag: string): boolean;
+    remove(tag: string): void;
+    setSuggestions(suggestions: string[]): void;
+    readonly value: string[];
+}
+declare function createTagInput(root: HTMLElement | null, settings?: TagInputOptions): TagInputInstance;
+
+interface DateTimePickerOptions {
+    /** A Date or 'YYYY-MM-DDTHH:MM' (local). */
+    value?: DateInput | null;
+    min?: DateInput | null;
+    max?: DateInput | null;
+    locale?: string;
+    hourCycle?: 12 | 24;
+    /** Arrow step of the minutes (default 5). */
+    minuteStep?: number;
+    firstDay?: number;
+    unavailable?: string[] | ((day: Date) => boolean);
+    /** Override "today" (demos, tests). */
+    today?: DateInput;
+    /** Accessible name of the field (default 'Fecha y hora'). */
+    label?: string;
+    /** Hidden input with 'YYYY-MM-DDTHH:MM'. */
+    name?: string;
+    disabled?: boolean;
+    onChange?: (value: Date | null) => void;
+}
+interface DateTimePickerInstance extends Instance {
+    open(): void;
+    close(): void;
+    setValue(value: DateInput | null): void;
+    readonly value: Date | null;
+    readonly isOpen: boolean;
+}
+/** A local date-time from a Date or 'YYYY-MM-DD[T ]HH:MM[:SS]'; null when unreadable. */
+declare function toDateTimeValue(input: DateInput | null | undefined): Date | null;
+/** 'YYYY-MM-DDTHH:MM' of a local date-time (what <input type="datetime-local"> posts). */
+declare const dateTimeKey: (date: Date) => string;
+declare function createDateTimePicker(root: HTMLElement | null, options?: DateTimePickerOptions): DateTimePickerInstance;
+
+type FilterFieldType = 'text' | 'number' | 'date' | 'select' | 'boolean';
+interface FilterField {
+    key: string;
+    label: string;
+    type?: FilterFieldType;
+    /** 'select' fields: the values to choose from. */
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+type FilterValue = string | number | null | [string | number | null, string | number | null];
+interface FilterRule {
+    id: string;
+    field: string;
+    operator: string;
+    value?: FilterValue;
+}
+interface FilterGroup {
+    id: string;
+    combinator: 'and' | 'or';
+    rules: FilterNode[];
+}
+type FilterNode = FilterRule | FilterGroup;
+interface OperatorDef {
+    id: string;
+    label: string;
+    /** How many values it takes. */
+    arity: 0 | 1 | 2;
+}
+declare const OPERATORS: Record<FilterFieldType, OperatorDef[]>;
+declare const emptyFilter: (combinator?: "and" | "or") => FilterGroup;
+/** Whether `record` passes `filter`; incomplete conditions (and empty groups) do not filter. */
+declare function matchesFilter(record: Record<string, unknown>, filter: FilterGroup, fields: FilterField[]): boolean;
+/** The group holds at least one complete condition (at any depth). */
+declare function hasConditions(filter: FilterGroup, fields: FilterField[]): boolean;
+/** The filter as a sentence; incomplete conditions are left out. Empty: ''. */
+declare function describeFilter(filter: FilterGroup, fields: FilterField[], nested?: boolean): string;
+
+interface FilterBuilderOptions {
+    /** The fields to filter by (without them the builder stays inert). */
+    fields?: FilterField[];
+    value?: FilterGroup;
+    /** Levels of groups (default 2: groups inside the main one). */
+    maxDepth?: number;
+    /** Accessible name (default 'Filtros'). */
+    label?: string;
+    /** The sentence under the builder (default true). */
+    summary?: boolean;
+    onChange?: (filter: FilterGroup) => void;
+}
+interface FilterBuilderInstance extends Instance {
+    setValue(filter: FilterGroup): void;
+    clear(): void;
+    readonly value: FilterGroup;
+    readonly summary: string;
+}
+declare function createFilterBuilder(root: HTMLElement | null, options?: FilterBuilderOptions): FilterBuilderInstance;
+
+type TimeInput = Date | string | number;
+/** "ahora", "hace 5 min", "hace 2 h", "ayer", "hace 3 días", then "12 nov." (with the year when it differs). */
+declare function relativeTime(date: Date, now?: Date, locale?: string): string;
+/** "Hoy", "Ayer", "Mañana", else "Lunes, 12 de noviembre" (with the year when it differs). */
+declare function dayLabel(date: Date, now?: Date, locale?: string): string;
+
+type TimelineStatus = 'done' | 'current' | 'upcoming' | 'error';
+interface TimelineEvent {
+    id: string;
+    title: string;
+    description?: string;
+    time?: TimeInput;
+    status?: TimelineStatus;
+    /** A short glyph in the dot (an emoji or one or two letters). */
+    icon?: string;
+    /** Small text under it (an author, a place). */
+    meta?: string;
+}
+interface TimelineOptions {
+    events?: TimelineEvent[];
+    /** 'start' (default): the rail on the left; 'alternate': both sides on wide screens. */
+    layout?: 'start' | 'alternate';
+    /** A heading for each day (default false). */
+    group?: boolean;
+    /** Times as "hace 2 h", refreshed every minute (default true); false shows the date and time. */
+    relative?: boolean;
+    locale?: string;
+    /** Accessible name of the list (default 'Historial'). */
+    label?: string;
+}
+interface TimelineInstance extends Instance {
+    add(event: TimelineEvent, at?: 'start' | 'end'): void;
+    update(id: string, patch: Partial<Omit<TimelineEvent, 'id'>>): void;
+    remove(id: string): void;
+    setEvents(events: TimelineEvent[]): void;
+    readonly events: TimelineEvent[];
+}
+declare function createTimeline(root: HTMLElement | null, options?: TimelineOptions): TimelineInstance;
+
+interface ActivityActor {
+    name: string;
+    /** A picture URL; without it, the initials. */
+    avatar?: string;
+}
+type ActivityKind = 'comment' | 'create' | 'update' | 'delete' | 'upload' | 'complete' | 'mention';
+interface ActivityItem {
+    id: string;
+    actor: ActivityActor | string;
+    /** The verb: "comentó en", "cerró", "subió". */
+    action: string;
+    /** What it was done to. */
+    target?: string;
+    /** A link for the target. */
+    href?: string;
+    time: TimeInput;
+    /** A quote under it (the comment). */
+    detail?: string;
+    kind?: ActivityKind;
+}
+interface ActivityFeedOptions {
+    items?: ActivityItem[];
+    locale?: string;
+    /** Accessible name (default 'Actividad'). */
+    label?: string;
+    /** Older entries for "Cargar más": resolve with them, or with [] when there are no more. */
+    onLoadMore?: () => Promise<ActivityItem[]> | ActivityItem[];
+    emptyLabel?: string;
+}
+interface ActivityFeedInstance extends Instance {
+    /** New activity on top (or behind the "novedades" pill when the reader is scrolled down). */
+    prepend(items: ActivityItem[]): void;
+    append(items: ActivityItem[]): void;
+    setItems(items: ActivityItem[]): void;
+    readonly items: ActivityItem[];
+}
+declare function createActivityFeed(root: HTMLElement | null, options?: ActivityFeedOptions): ActivityFeedInstance;
+
+interface TreeNode {
+    id: string;
+    label: string;
+    children?: TreeNode[];
+    /** A short glyph before the label. */
+    icon?: string;
+    disabled?: boolean;
+    /** Has children that loadChildren() will bring. */
+    hasChildren?: boolean;
+    /** Anything the app wants to keep with the node. */
+    data?: unknown;
+}
+type CheckState = 'true' | 'false' | 'mixed';
+/** The node with `id` and the path from the top to it (it included). */
+declare function findNode(nodes: TreeNode[], id: string): {
+    node: TreeNode;
+    path: TreeNode[];
+} | null;
+/** Each node's state: leaves from `checked`, branches from their children (the enabled ones, when there are). */
+declare function checkStates(nodes: TreeNode[], checked: Set<string>): Map<string, CheckState>;
+/** Check or uncheck `id` and everything under it but disabled nodes; returns the new set (branches follow their children). */
+declare function toggleCheck(nodes: TreeNode[], checked: Set<string>, id: string, value?: boolean): Set<string>;
+/**
+ * The nodes whose text has `query` (accents and case ignored), the ancestors
+ * that keep them visible, and the branches to open to show them.
+ */
+declare function searchTree(nodes: TreeNode[], query: string, text?: (node: TreeNode) => string): {
+    matches: Set<string>;
+    visible: Set<string>;
+    open: Set<string>;
+    active: boolean;
+};
+
+interface TreeViewOptions {
+    nodes?: TreeNode[];
+    /** Three-state checkboxes (default false). */
+    checkable?: boolean;
+    checked?: string[];
+    /** Open at the start: ids, or true for every branch. */
+    expanded?: string[] | boolean;
+    selected?: string | null;
+    /** A search field above the tree: true, or its placeholder. */
+    search?: boolean | string;
+    /** Accessible name (default 'Árbol'). */
+    label?: string;
+    /** Children of a branch with hasChildren, the first time it opens. */
+    loadChildren?: (node: TreeNode) => Promise<TreeNode[]> | TreeNode[];
+    /** Draw a label yourself (json-viewer, file-explorer); `query` is the search, for marking. */
+    renderLabel?: (node: TreeNode, element: HTMLElement, query: string) => void;
+    /** The text the search looks in (default: the label). */
+    searchText?: (node: TreeNode) => string;
+    onSelect?: (node: TreeNode) => void;
+    onCheck?: (checked: string[]) => void;
+    onExpand?: (node: TreeNode, expanded: boolean) => void;
+}
+interface TreeViewInstance extends Instance {
+    expand(id: string, animate?: boolean): void;
+    collapse(id: string, animate?: boolean): void;
+    toggle(id: string): void;
+    expandAll(): void;
+    collapseAll(): void;
+    /** Open the branches above it and bring it into view. */
+    reveal(id: string): void;
+    select(id: string | null, notify?: boolean): void;
+    setChecked(ids: string[]): void;
+    filter(query: string): void;
+    setNodes(nodes: TreeNode[]): void;
+    focusItem(id: string): void;
+    readonly selected: string | null;
+    readonly checked: string[];
+    readonly expanded: string[];
+    /** The tree element (role="tree"). */
+    readonly element: HTMLElement;
+}
+
+declare function createTreeView(root: HTMLElement | null, options?: TreeViewOptions): TreeViewInstance;
+
+interface FileEntry {
+    id: string;
+    name: string;
+    /** 'folder' or 'file'; without it, an entry with children is a folder. */
+    kind?: 'folder' | 'file';
+    children?: FileEntry[];
+    /** Bytes. */
+    size?: number;
+    modified?: TimeInput;
+}
+type FileFamily = 'folder' | 'image' | 'pdf' | 'doc' | 'sheet' | 'slides' | 'code' | 'archive' | 'media' | 'other';
+type FileSort = 'name' | 'size' | 'modified';
+declare function fileFamily(entry: FileEntry): FileFamily;
+/** "820 B", "12 KB", "3,4 MB" (in the given language). */
+declare function formatSize(bytes: number, locale?: string): string;
+/** Folders first; then by `key` (names in natural order: "Foto 2" before "Foto 10"). */
+declare function sortEntries(entries: FileEntry[], key?: FileSort, direction?: 1 | -1, locale?: string): FileEntry[];
+
+type FileView = 'list' | 'grid';
+type FileChange = {
+    type: 'create';
+    id: string;
+    parent: string;
+} | {
+    type: 'rename';
+    id: string;
+    name: string;
+} | {
+    type: 'delete';
+    ids: string[];
+} | {
+    type: 'move';
+    ids: string[];
+    to: string;
+};
+interface FileExplorerOptions {
+    /** What the top folder holds. */
+    files?: FileEntry[];
+    /** Name of the top folder (default 'Inicio'). */
+    rootLabel?: string;
+    /** The folder open at the start (default: the top one, '/'). */
+    folder?: string;
+    view?: FileView;
+    /** The folder tree beside the content (default true; it hides on narrow widths). */
+    tree?: boolean;
+    /** No new folders, renaming, deleting or moving (default false). */
+    readOnly?: boolean;
+    locale?: string;
+    /** Accessible name (default 'Explorador de archivos'). */
+    label?: string;
+    /** A file was opened (double click or Enter). */
+    onOpen?: (entry: FileEntry) => void;
+    onNavigate?: (folder: FileEntry) => void;
+    onSelectionChange?: (ids: string[]) => void;
+    onViewChange?: (view: FileView) => void;
+    /** After every change (new folder, rename, delete, move), with all the files. */
+    onChange?: (files: FileEntry[], change: FileChange) => void;
+}
+interface FileExplorerInstance extends Instance {
+    /** Open a folder, or a file (its folder opens and onOpen is called). */
+    open(id: string): void;
+    up(): void;
+    setView(view: FileView): void;
+    select(ids: string[]): void;
+    /** A new folder in the open one; its name is asked for in place. Returns its id. */
+    createFolder(name?: string): string | null;
+    /** With a name, renames at once; without one, asks for it in place. */
+    rename(id: string, name?: string): void;
+    /** Deletes these entries (default: the selection). */
+    remove(ids?: string[]): void;
+    move(ids: string[], folder: string): void;
+    setFiles(files: FileEntry[]): void;
+    readonly files: FileEntry[];
+    /** The open folder's id ('/' for the top one). */
+    readonly folder: string;
+    readonly selection: string[];
+    readonly view: FileView;
+}
+declare function createFileExplorer(root: HTMLElement | null, options?: FileExplorerOptions): FileExplorerInstance;
+
+type JsonType = 'object' | 'array' | 'string' | 'number' | 'boolean' | 'null';
+interface JsonViewerOptions {
+    /** The value; without it, the JSON written inside the root (as text or in a <script type="application/json">). */
+    data?: unknown;
+    /** Levels open at the start: 1 shows the top keys closed, 2 opens them… (default 1; Infinity opens all). */
+    expandDepth?: number;
+    /** A row for the value itself with this name; without it the top keys are the first rows. */
+    rootName?: string;
+    /** A search field: true, or its placeholder (default false). */
+    search?: boolean | string;
+    /** The bar with expand, collapse and copy (default true). */
+    toolbar?: boolean;
+    /** Keys in alphabetical order (default false: as they come). */
+    sortKeys?: boolean;
+    /** Accessible name (default 'Datos JSON'). */
+    label?: string;
+    onSelect?: (path: string, value: unknown) => void;
+    onCopy?: (text: string, path: string) => void;
+}
+interface JsonViewerInstance extends Instance {
+    setData(data: unknown): void;
+    expandAll(): void;
+    collapseAll(): void;
+    /** Open the rows down to this path ($.user.roles) and show it. */
+    reveal(path: string): void;
+    filter(query: string): void;
+    /** Copy a value (default: all of it) as text. */
+    copy(path?: string): Promise<boolean>;
+    readonly data: unknown;
+}
+/** $.user, $.items[0], $["con espacios"]. */
+declare const jsonPath: (parent: string, key: string | number) => string;
+declare function createJsonViewer(root: HTMLElement | null, options?: JsonViewerOptions): JsonViewerInstance;
+
+interface VirtualRange {
+    /** First row drawn. */
+    start: number;
+    /** One past the last row drawn. */
+    end: number;
+}
+interface VirtualSizes {
+    readonly count: number;
+    get(index: number): number;
+    /** A row's height; true when it changed. */
+    set(index: number, height: number): boolean;
+    /** The top of a row (the sum of the heights before it). */
+    offset(index: number): number;
+    total(): number;
+    /** The row at a vertical position (clamped to the list). */
+    indexAt(y: number): number;
+    /** The rows that cover y … y + height, with `overscan` more on each side. */
+    range(y: number, height: number, overscan?: number): VirtualRange;
+}
+declare function createSizes(heights: number[]): VirtualSizes;
+
+type VirtualKey = string | number;
+interface VirtualListOptions<T = unknown> {
+    items?: T[];
+    /** Every row this tall (fastest); without it rows are measured. */
+    itemHeight?: number;
+    /** Height of a row not measured yet (default: itemHeight, else 48). */
+    estimatedHeight?: number;
+    /** Rows drawn beyond each edge (default 6). */
+    overscan?: number;
+    /** Draw a row into its element (recycled: draw all of it every time). Default: its text. */
+    renderItem?: (item: T, index: number, element: HTMLElement) => void;
+    /** A row's text: the default drawing, typing to jump and announcements (default: label, title, name or the value). */
+    itemText?: (item: T) => string;
+    /** A stable key for a row (default: its id, else its index). */
+    getKey?: (item: T, index: number) => VirtualKey;
+    /** Rows can be chosen: true or 'single', or 'multiple' (default false). */
+    selectable?: boolean | 'single' | 'multiple';
+    selected?: VirtualKey[];
+    /** Accessible name (default 'Lista'). */
+    label?: string;
+    emptyLabel?: string;
+    locale?: string;
+    onSelect?: (keys: VirtualKey[], items: T[]) => void;
+    /** Enter or a double click on a row. */
+    onActivate?: (item: T, index: number) => void;
+    /** More rows at the end: resolve with them, with [] when there are no more, or with nothing when you add them yourself (setItems). */
+    onEndReached?: () => Promise<T[] | void> | T[] | void;
+    /** Draw the rows yourself (frameworks): told which ones; put them in `container` as [data-mk-vl-item][data-index] and call refresh(). */
+    onRange?: (range: VirtualRange) => void;
+}
+interface VirtualScrollOptions {
+    align?: 'auto' | 'start' | 'center' | 'end';
+    animate?: boolean;
+}
+interface VirtualListInstance<T = unknown> extends Instance {
+    setItems(items: T[]): void;
+    /** Add rows at the end. */
+    append(items: T[]): void;
+    scrollToIndex(index: number, options?: VirtualScrollOptions): void;
+    /** Position and measure the drawn rows again (after drawing them yourself, or when their content changed). */
+    refresh(): void;
+    select(keys: VirtualKey[]): void;
+    /** Change how rows are drawn (vanilla). */
+    setRenderer(renderItem: (item: T, index: number, element: HTMLElement) => void): void;
+    readonly items: T[];
+    readonly range: VirtualRange;
+    readonly selected: VirtualKey[];
+    /** Where the rows live. */
+    readonly container: HTMLElement;
+}
+declare function createVirtualList<T = unknown>(root: HTMLElement | null, options?: VirtualListOptions<T>): VirtualListInstance<T>;
+
+type PanelOrientation = 'horizontal' | 'vertical';
+interface ResizablePanelOptions {
+    /** 'horizontal' (default): side by side; 'vertical': stacked. */
+    orientation?: PanelOrientation;
+    /** Sizes in percent, one per panel (default: data-size on the panels, else equal). */
+    sizes?: number[];
+    /** Smallest size of a panel in percent (default 10; data-min on a panel wins). */
+    min?: number;
+    /** Largest size of a panel in percent (default 100; data-max on a panel wins). */
+    max?: number;
+    /** Panels (indexes) that snap shut when dragged well under their minimum; data-collapsible on a panel too. */
+    collapsible?: number[];
+    /** Panels that start shut. */
+    collapsed?: number[];
+    /** Arrow keys move this many percent (default 5; Shift: four times). */
+    step?: number;
+    /** Remember sizes in localStorage under this key. */
+    storageKey?: string;
+    /** Buttons on each separator to shut and open the panels beside it. */
+    handleButtons?: boolean;
+    /** Names of the panels, for the separators' labels (default: data-label, else "panel 1"…). */
+    labels?: string[];
+    /** While it moves (once a frame). */
+    onResize?: (sizes: number[]) => void;
+    /** When a drag, a key or an animation ends. */
+    onResizeEnd?: (sizes: number[]) => void;
+    onCollapse?: (index: number, collapsed: boolean) => void;
+}
+interface ResizablePanelInstance extends Instance {
+    setSizes(sizes: number[], animate?: boolean): void;
+    collapse(index: number): void;
+    expand(index: number): void;
+    toggle(index: number): void;
+    /** The first sizes again. */
+    reset(): void;
+    setOrientation(orientation: PanelOrientation): void;
+    readonly sizes: number[];
+    readonly collapsed: number[];
+    readonly orientation: PanelOrientation;
+}
+/** Sizes that add up to 100: missing ones share what is left, then all scale to 100 (all missing: equal). */
+declare function normaliseSizes(sizes: Array<number | undefined>, count: number): number[];
+declare function createResizablePanel(root: HTMLElement | null, options?: ResizablePanelOptions): ResizablePanelInstance;
+
+type SplitSide = 'start' | 'end';
+interface SplitViewOptions {
+    /** 'horizontal' (default): side by side; 'vertical': one over the other. */
+    orientation?: PanelOrientation;
+    /** The first area's share, 0–1 (default .5). */
+    ratio?: number;
+    /** Smallest share of an area in percent (default 15). */
+    min?: number;
+    /** Which sides can shut: true (default) both, 'start', 'end' or false. */
+    collapsible?: boolean | SplitSide;
+    /** Stack the areas when the view is narrower than this many pixels (default 0: never). */
+    stackBelow?: number;
+    storageKey?: string;
+    /** Names of the two areas (default 'Primera área', 'Segunda área'; or their data-label). */
+    labels?: [string, string];
+    /** After a change of the split ends. */
+    onChange?: (ratio: number) => void;
+    onCollapse?: (side: SplitSide | null) => void;
+}
+interface SplitViewInstance extends Instance {
+    setRatio(ratio: number, animate?: boolean): void;
+    collapse(side: SplitSide): void;
+    /** Open the side that is shut. */
+    expand(): void;
+    toggle(side: SplitSide): void;
+    readonly ratio: number;
+    readonly collapsed: SplitSide | null;
+    readonly orientation: PanelOrientation;
+}
+declare function createSplitView(root: HTMLElement | null, options?: SplitViewOptions): SplitViewInstance;
+
+type DataColumnType = 'text' | 'number' | 'date' | 'boolean' | 'select';
+type DataRow = Record<string, unknown>;
+type RowId = string | number;
+type SortDirection = 'asc' | 'desc';
+interface DataSort {
+    key: string;
+    direction: SortDirection;
+}
+interface DataColumn<T extends DataRow = DataRow> {
+    key: string;
+    label: string;
+    /** For sorting, filtering and the default text (default 'text'). */
+    type?: DataColumnType;
+    /** The choices of a 'select' column (its text and its filter). */
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    sortable?: boolean;
+    filterable?: boolean;
+    searchable?: boolean;
+    /** Starts hidden (it can be shown from "Columnas"). */
+    hidden?: boolean;
+    /** Can be hidden from "Columnas" (default true). */
+    hideable?: boolean;
+    align?: 'start' | 'center' | 'end';
+    width?: string;
+    /** The cell's text (default: numbers and dates in the page's language, Sí/No, the choice's label). */
+    format?: (value: unknown, row: T) => string;
+    /** Draw the cell yourself (vanilla). */
+    render?: (value: unknown, row: T, cell: HTMLTableCellElement) => void;
+    /** The value to sort, filter and search by (default row[key]). */
+    value?: (row: T) => unknown;
+}
+interface DataAction {
+    id: string;
+    label: string;
+    danger?: boolean;
+}
+interface DataTableOptions<T extends DataRow = DataRow> {
+    columns?: DataColumn<T>[];
+    rows?: T[];
+    /** The rows' id: a key (default 'id') or a function. */
+    rowKey?: string | ((row: T) => RowId);
+    /** Accessible name (default 'Tabla'). */
+    caption?: string;
+    /** Rows a page (default 10; 0: all of them). */
+    pageSize?: number;
+    pageSizes?: number[];
+    selectable?: boolean;
+    /** A search field: true, or its placeholder (default true). */
+    search?: boolean | string;
+    /** A "Filtros" button with filter-builder (default true). */
+    filters?: boolean;
+    filter?: FilterGroup;
+    /** A "Columnas" button to show and hide columns (default true). */
+    columnsMenu?: boolean;
+    /** A menu on each row. */
+    actions?: DataAction[];
+    /** Buttons in the bar of the chosen rows. */
+    bulkActions?: DataAction[];
+    sort?: DataSort | null;
+    loading?: boolean;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    locale?: string;
+    onSortChange?: (sort: DataSort | null) => void;
+    onSelectionChange?: (ids: RowId[], rows: T[]) => void;
+    onAction?: (action: string, row: T) => void;
+    onBulkAction?: (action: string, rows: T[]) => void;
+    onPageChange?: (page: number) => void;
+    onFilterChange?: (filter: FilterGroup, query: string) => void;
+    /** After the rows are drawn (editable-table decorates them). */
+    onRender?: (body: HTMLTableSectionElement) => void;
+}
+interface DataTableInstance<T extends DataRow = DataRow> extends Instance {
+    setRows(rows: T[]): void;
+    updateRow(id: RowId, patch: Partial<T>): void;
+    /** Rows slide out and the rest close the gap. */
+    removeRows(ids: RowId[]): void;
+    setLoading(loading: boolean): void;
+    sortBy(key: string | null, direction?: SortDirection): void;
+    setPage(page: number): void;
+    setPageSize(size: number): void;
+    setQuery(query: string): void;
+    setFilter(filter: FilterGroup): void;
+    setColumnVisible(key: string, visible: boolean): void;
+    select(ids: RowId[]): void;
+    rowOf(id: RowId): HTMLTableRowElement | null;
+    cellOf(id: RowId, key: string): HTMLTableCellElement | null;
+    /** Draw the rows again (after changing them in place). */
+    refresh(): void;
+    idOf(row: T): RowId;
+    readonly rows: T[];
+    /** The rows the search and the filters leave, in order. */
+    readonly results: T[];
+    readonly page: number;
+    readonly pageCount: number;
+    readonly selection: RowId[];
+    readonly sort: DataSort | null;
+    readonly query: string;
+    readonly filter: FilterGroup;
+    readonly columns: DataColumn<T>[];
+    readonly body: HTMLTableSectionElement;
+}
+declare function createDataTable<T extends DataRow = DataRow>(root: HTMLElement | null, options?: DataTableOptions<T>): DataTableInstance<T>;
+
+type EditorKind = 'text' | 'number' | 'date' | 'select' | 'checkbox';
+interface EditableColumn<T extends DataRow = DataRow> extends DataColumn<T> {
+    /** Can be edited (default true). */
+    editable?: boolean;
+    /** The editor (default: from the column's type). */
+    editor?: EditorKind;
+    required?: boolean;
+    min?: number;
+    max?: number;
+    /** An error message, or nothing when the value is fine. */
+    validate?: (value: unknown, row: T) => string | null | undefined | void;
+}
+interface RowChange<T extends DataRow = DataRow> {
+    id: RowId;
+    /** The row as it is now (as it was, for a removed one). */
+    row: T;
+    /** The values that changed (all of them for a new row). */
+    changes: Partial<T>;
+    isNew?: boolean;
+    removed?: boolean;
+}
+interface EditableTableOptions<T extends DataRow = DataRow> extends Omit<DataTableOptions<T>, 'columns'> {
+    columns?: EditableColumn<T>[];
+    /** Keep the changes: resolve when they are saved; reject (or throw) to keep them pending. */
+    onSave?: (changes: RowChange<T>[], rows: T[]) => Promise<void> | void;
+    /** After every edit. */
+    onChange?: (changes: RowChange<T>[]) => void;
+    /** A new row's values: shows "Agregar fila". */
+    newRow?: () => Partial<T>;
+}
+interface EditableTableInstance<T extends DataRow = DataRow> extends Instance {
+    /** Open a cell's editor. */
+    edit(id: RowId, key: string): void;
+    setValue(id: RowId, key: string, value: unknown): boolean;
+    addRow(values?: Partial<T>): RowId;
+    removeRows(ids: RowId[]): void;
+    save(): Promise<boolean>;
+    discard(): void;
+    setRows(rows: T[]): void;
+    readonly changes: RowChange<T>[];
+    readonly dirty: boolean;
+    readonly rows: T[];
+    readonly table: DataTableInstance<T>;
+}
+declare function createEditableTable<T extends DataRow = DataRow>(root: HTMLElement | null, options?: EditableTableOptions<T>): EditableTableInstance<T>;
+
+type RichCommand = 'bold' | 'italic' | 'underline' | 'strike' | 'h2' | 'h3' | 'ul' | 'ol' | 'quote' | 'code' | 'link' | 'clear' | 'undo' | 'redo';
+interface RichTextEditorOptions {
+    /** The first content, as HTML (cleaned like a paste). */
+    value?: string;
+    placeholder?: string;
+    /** The buttons, in order; '|' separates groups (default: all). */
+    toolbar?: Array<RichCommand | '|'>;
+    /** Characters before the counter turns red (the text can go on). */
+    maxLength?: number;
+    /** 'words' (default), 'characters', or false. */
+    counter?: 'words' | 'characters' | false;
+    /** A hidden field with this name carries the HTML. */
+    name?: string;
+    /** Accessible name of the writing area (default 'Editor de texto'). */
+    label?: string;
+    readOnly?: boolean;
+    /** Markdown shortcuts while typing (default true). */
+    markdown?: boolean;
+    onChange?: (html: string, text: string) => void;
+}
+interface RichTextEditorInstance extends Instance {
+    setValue(html: string): void;
+    focus(): void;
+    exec(command: RichCommand, value?: string): void;
+    readonly value: string;
+    readonly text: string;
+    readonly element: HTMLElement;
+}
+/** HTML with only safe formatting: known tags (renamed to their kind), links with safe addresses, no attributes else. */
+declare function sanitizeHtml(html: string): string;
+declare function createRichTextEditor(root: HTMLElement | null, options?: RichTextEditorOptions): RichTextEditorInstance;
+
+/**
+ * Every duration in one place (seconds, like GSAP, unless the name says
+ * ms). Recipes and components take their defaults from here, so a timing is
+ * changed once.
+ */
+declare const TIMING: Readonly<{
+    flow: 0.5;
+    flowStagger: 0.05;
+    stepChange: 0.5;
+    reveal: Readonly<{
+        readonly fast: readonly [0.5, 0.25];
+        readonly normal: readonly [0.7, 0.35];
+        readonly slow: readonly [1.05, 0.5];
+        readonly slower: readonly [1.6, 0.75];
+    }>;
+    details: 0.32;
+    chevron: 0.25;
+    indicator: 0.45;
+    number: 0.6;
+    numberPricing: 0.7;
+    revealCounter: 0.9;
+    layoutTravel: 0.62;
+    /** New items in a reflow enter in this share of the travel time. */
+    layoutEnterFactor: 0.6;
+    menu: Readonly<{
+        duration: 0.35;
+        stagger: 0.04;
+        delay: 0.1;
+    }>;
+    palette: Readonly<{
+        duration: 0.1;
+        stagger: 0.01;
+    }>;
+    form: Readonly<{
+        duration: 0.35;
+        stagger: 0.04;
+    }>;
+    landing: Readonly<{
+        duration: 0.4;
+        stagger: 0.05;
+        delay: 0.15;
+    }>;
+    content: Readonly<{
+        duration: 0.6;
+        stagger: 0.06;
+    }>;
+    bubble: 0.7;
+    bubbleStagger: 0.06;
+    word: 0.25;
+    wordStagger: 0.05;
+    chatScroll: 0.35;
+    composer: 0.18;
+    slot: Readonly<{
+        durationMs: 300;
+        staggerMs: 45;
+        exitOffsetMs: 50;
+        colorFadeMs: 280;
+        maxTilt: 5;
+        minResizeMs: 140;
+    }>;
+    swatch: 0.5;
+    swatchLight: 3.5;
+    swatchBackground: 4.5;
+    /** ModalHost (modal-origin, modal-close-origin, modal-fallback, modal-auto-resize). */
+    dialog: Readonly<{
+        /** The surface travels from its opener. */
+        open: 0.7;
+        /** The opener's colour hands over to the surface's. */
+        surfaceColor: 0.3;
+        /** Back into the opener. */
+        close: 0.5;
+        /** While closing, the content heads for the opener on a 2 s path cut at `close`. */
+        contentReturn: 2;
+        originHide: 0.08;
+        originShow: 0.3;
+        originShowDelay: 0.2;
+        /** No opener on screen: scale .92 → 1. */
+        fallback: 0.35;
+        autoResize: 0.45;
+        /** Backdrop tint on the signature curve. */
+        backdrop: 0.5;
+        /** Items of a list that opens from its control. */
+        list: 0.25;
+    }>;
+    /** modal-liquid (spring channels; springs are stiffness/damping, not times). */
+    liquid: Readonly<{
+        size: 0.3;
+        radius: 0.7;
+        content: 0.3;
+        color: 0.4;
+        colorDelay: 0.15;
+        ghost: 0.25;
+        ghostDelay: 0.05;
+        closeSize: 0.25;
+        closeContent: 0.3;
+        originRestore: 0.3;
+        originRestoreDelay: 0.2;
+        safetyMs: 1100;
+    }>;
+    /** modal-drag: the spring back when a drag is not far enough. */
+    drag: Readonly<{
+        restore: 0.5;
+        radiusRestore: 0.3;
+    }>;
+    /** modal-float. */
+    float: Readonly<{
+        shadow: 0.45;
+        glideDecay: 0.18;
+        sizeSmoothing: 0.08;
+    }>;
+    /** chat-loader-delay, chat-confirmation-bar. */
+    chat: Readonly<{
+        pendingDelayMs: 500;
+        confirmWordStagger: 0.1;
+    }>;
+    /** onboarding-busy-background, step-change, onboarding-reveal-counter. */
+    onboarding: Readonly<{
+        busy: 0.8;
+        idle: 0.6;
+        step: 0.5;
+        counter: 0.9;
+    }>;
+    /** task-drag: lift, land (FA .62), crossfade (66 % of the land), neighbours shifting (FA .52). */
+    sortable: Readonly<{
+        lift: 0.18;
+        land: 0.42;
+        landFade: number;
+        shift: 0.62;
+    }>;
+    /** toast-deck, toast-morph, toast-character-reveal. */
+    toast: Readonly<{
+        relayout: 0.6;
+        expand: 0.55;
+        expandStagger: 0.06;
+        enter: 0.5;
+        exit: 0.3;
+        collapseDelayMs: 150;
+        morphSize: 0.32;
+        morphRadius: 0.7;
+        morphContent: 0.32;
+        morphColor: 0.4;
+        morphColorDelay: 0.15;
+        morphShadow: 0.6;
+        morphShadowDelay: 0.05;
+        safetyMs: 1100;
+        chars: 0.4;
+        charsDelay: 0.225;
+        charsStagger: 0.02;
+    }>;
+    /** glass (CSS): surface/shadow transitions, ring and shine. */
+    glass: Readonly<{
+        hover: 0.4;
+        ring: 0.5;
+    }>;
+    /** utility animations (css/effects/anim.css), by name. */
+    effects: Readonly<{
+        out: 0.5;
+        'out-left': 0.5;
+        'out-bottom': 0.5;
+        collapse: 0.25;
+        highlight: 1;
+        shake: 0.5;
+        'shake-strong': 0.4;
+        fade: 0.3;
+        wipe: 0.7;
+        'progress-in': 1;
+    }>;
+    /** success confetti, per 60 fps frame. */
+    confetti: Readonly<{
+        count: 45;
+        speed: readonly [2, 8];
+        lift: 2;
+        radius: readonly [3, 7];
+        decay: readonly [0.015, 0.03];
+        gravity: 0.15;
+        drag: 0.98;
+        spin: 2.5;
+    }>;
+    /** project sheet. */
+    sheet: Readonly<{
+        open: 0.72;
+        close: 0.72;
+        underlayScale: 0.98;
+        underlayOpacity: 0.4;
+    }>;
+    /** Physical spring pairs: [stiffness, damping]. */
+    springs: Readonly<{
+        press: readonly [400, 10];
+        success: readonly [260, 18];
+        underlay: readonly [300, 30];
+        letters: readonly [300, 10];
+        cursorFollow: readonly [800, 35];
+        cursorAppear: readonly [500, 30];
+        bentoEnter: readonly [60, 15];
+        bentoRepel: readonly [300, 25];
+        dockPill: readonly [380, 30];
+    }>;
+    /** masked type. */
+    maskText: Readonly<{
+        duration: 1.2;
+        delay: 0.1;
+        stagger: 0.02;
+        exitStagger: 0.002;
+        y: 100;
+        threshold: 0.8;
+    }>;
+    /** reveal group (rules, fades, rises). */
+    cascade: Readonly<{
+        duration: 1.2;
+        step: 0.03;
+        rise: 200;
+        threshold: 0.3;
+    }>;
+    /** slot title: each letter turns 8–14 times inside a 2 s expo.out envelope. */
+    textRoll: Readonly<{
+        duration: 2;
+        stagger: 0.04;
+        turns: readonly [8, 14];
+        interval: 6000;
+        quietMs: 1000;
+    }>;
+    /** hero letters: scale on hover, pastel blink. */
+    letters: Readonly<{
+        scale: 1.3;
+        y: -5;
+        step: 0.03;
+        blink: 0.6;
+        blinkStart: 0.6;
+        blinkRepeatDelay: 0.1;
+        blinkDelays: readonly [0.1, 0.6, 0.2, 1, 0.4, 1.2, 0.15, 0.8, 0.3];
+    }>;
+    /** image parallax. */
+    parallax: Readonly<{
+        travel: 10;
+        scale: 1.2;
+        strongScale: 1.3;
+        lerp: 1;
+    }>;
+    /** About grid gathering from depth. */
+    depthGrid: Readonly<{
+        perspective: 600;
+        distance: 900;
+        depth: -3000;
+        rotate: -160;
+        opacity: 0.05;
+        scale: 0.4;
+        stagger: 0.15;
+        lerp: 1;
+    }>;
+    /** video mask: the frame and the picture inside scale in opposite directions. */
+    frameZoom: Readonly<{
+        outer: readonly [80, 20];
+        inner: readonly [130, 20];
+        phoneOuter: readonly [95, 5];
+        phoneInner: readonly [105, 5];
+        open: 1;
+        lerp: 1;
+    }>;
+    /** marquee: seconds per item, at most 14 counted. */
+    marquee: Readonly<{
+        perItem: 2;
+        maxItems: 14;
+    }>;
+    /** glass chip and dot cursor. */
+    cursor: Readonly<{
+        gutter: 10;
+        circle: 96;
+        dotLerp: 0.2;
+        light: 180;
+    }>;
+    /** floating navbar: enters from −300 % over 1.8 s; rows follow 0.15 s + 0.025 s each. */
+    island: Readonly<{
+        entrance: 1.8;
+        offset: -300;
+        delay: 0.15;
+        step: 0.025;
+        focus: 150;
+    }>;
+    /** product dock: spread for 1.6 s on load; tablet range re-checked 250 ms after a resize. */
+    cardDock: Readonly<{
+        intro: 1600;
+        resizeDebounce: 250;
+    }>;
+    /** phone cards: 5 s a card, 2 s wait after a touch, 0.5 s after it shows. */
+    snapStrip: Readonly<{
+        interval: 5000;
+        resume: 2000;
+        delay: 500;
+    }>;
+    /** fill-text: letters from .2, 0.5 s each, 0.1 s apart, top 90 % → centre 40 %. */
+    fillText: Readonly<{
+        from: 0.2;
+        duration: 0.5;
+        stagger: 0.1;
+        start: "top 90%";
+        end: "center 40%";
+    }>;
+    /** particle hero: fade in 1 s after 0.3 s, morph cycles, pointer push. */
+    particleHero: Readonly<{
+        fadeIn: 1;
+        fadeDelay: 0.3;
+        size: 128;
+        pointSize: 1.7;
+        maxDpr: 1.5;
+        stillSteps: 110;
+    }>;
+    ticketMenu: Readonly<{
+        open: 0.9;
+        content: 1.1;
+        stagger: 0.02;
+        from: 150;
+    }>;
+    infiniteReel: Readonly<{
+        friction: 0.95;
+        wheel: 0.05;
+        dragThreshold: 5;
+    }>;
+    repelBento: Readonly<{
+        offset: 0.6;
+        stagger: 0.006;
+        strength: 5000;
+        distance: 30;
+        breakpoint: 1024;
+    }>;
+    rotator: Readonly<{
+        interval: 8000;
+        duration: 0.25;
+        y: 5;
+    }>;
+    dragRuler: Readonly<{
+        min: 0;
+        max: 8;
+        step: 0.1;
+        pixelsPerUnit: 60;
+    }>;
+}>;
+
+type RevealSpeed = keyof typeof TIMING.reveal;
+interface RevealOptions {
+    /** Element (its centre) or viewport point. Default: the last pointer position, else the centre. */
+    origin?: Element | {
+        x: number;
+        y: number;
+    } | null;
+    speed?: RevealSpeed;
+    delay?: number;
+    overshoot?: number;
+    /** Veil colour. Default: the first opaque background up the tree, else var(--mk-bg). */
+    fill?: string;
+}
+interface RevealHandle {
+    timeline: gsap.core.Timeline;
+    finished: Promise<void>;
+    /** Stop now and remove the veil. */
+    cancel(): void;
+}
+declare function revealFrom(target: HTMLElement, options?: RevealOptions): RevealHandle | null;
+
+export { createRichTextEditor as $, createColorArea as A, createColorField as B, createColorPicker as C, createTimeField as D, createRangeCalendar as E, createDateRangePicker as F, createTooltip as G, createPopover as H, createLoadingButton as I, createBreadcrumb as J, createEmptyState as K, createStatCard as L, createChartTooltip as M, createMultiSelect as N, createTagInput as O, createDateTimePicker as P, createFilterBuilder as Q, createTimeline as R, createActivityFeed as S, createTreeView as T, createFileExplorer as U, createJsonViewer as V, createVirtualList as W, createResizablePanel as X, createSplitView as Y, createDataTable as Z, createEditableTable as _, createTrailer as a, type DataTableOptions as a$, type RevealHandle as a0, type ActivityActor as a1, type ActivityFeedInstance as a2, type ActivityFeedOptions as a3, type ActivityItem as a4, type ActivityKind as a5, type AttachmentFile as a6, type AttachmentInstance as a7, type AttachmentLabels as a8, type AttachmentOptions as a9, type CodeBlockOptions as aA, type ColorAreaInstance as aB, type ColorAreaOptions as aC, type ColorChannel as aD, type ColorFieldInstance as aE, type ColorFieldOptions as aF, type ColorFormat as aG, type ColorPickerInstance as aH, type ColorPickerOptions as aI, type ColorSliderInstance as aJ, type ColorSliderOptions as aK, type CommandItem as aL, type CommandSearchInstance as aM, type CommandSearchOptions as aN, type ContextMenuInstance as aO, type ContextMenuOptions as aP, type CreditCardField as aQ, type CreditCardInstance as aR, type CreditCardLabels as aS, type CreditCardOptions as aT, type CreditCardValues as aU, type DataAction as aV, type DataColumn as aW, type DataColumnType as aX, type DataRow as aY, type DataSort as aZ, type DataTableInstance as a_, type AttachmentRejectCode as aa, type AttachmentRejection as ab, type AttachmentStatus as ac, BRAND_LABELS as ad, type BreadcrumbInstance as ae, type BreadcrumbItem as af, type BreadcrumbOptions as ag, CHANNEL_LABELS as ah, type CalendarEvent as ai, type CalendarEventStatus as aj, type CalendarInstance as ak, type CalendarLabels as al, type CalendarOptions as am, type CalendarRange as an, type CalendarView as ao, type CardBrand as ap, type ChartInstance as aq, type ChartOptions as ar, type ChartPoint as as, type ChartSeries as at, type ChartTooltipInstance as au, type ChartTooltipOptions as av, type ChartTooltipSeries as aw, type ChartType as ax, type CheckState as ay, type CodeBlockInstance as az, createQuantity as b, type PaginationOptions as b$, type DateInput as b0, type DateRange as b1, type DateRangePickerInstance as b2, type DateRangePickerOptions as b3, type DateTimePickerInstance as b4, type DateTimePickerOptions as b5, type DialogInstance as b6, type DialogLabels as b7, type DialogOptions as b8, type DialogPlacement as b9, type HoldConfirmOptions as bA, type HoverCardInstance as bB, type HoverCardOptions as bC, type Hsla as bD, type Hsva as bE, type ImagePreviewInstance as bF, type ImagePreviewOptions as bG, type InputOtpInstance as bH, type InputOtpOptions as bI, type JsonType as bJ, type JsonViewerInstance as bK, type JsonViewerOptions as bL, type LinkPreviewInstance as bM, type LinkPreviewOptions as bN, type LinkPreviewVariant as bO, type LoadingButtonInstance as bP, type LoadingButtonOptions as bQ, type LoadingState as bR, type MenuInstance as bS, type MenuOptions as bT, type MultiSelectInstance as bU, type MultiSelectOption as bV, type MultiSelectOptions as bW, type NotificationBellInstance as bX, type NotificationBellOptions as bY, OPERATORS as bZ, type PaginationInstance as b_, type DialogVariant as ba, type EditableColumn as bb, type EditableTableInstance as bc, type EditableTableOptions as bd, type EditorKind as be, type EmptyAction as bf, type EmptyIllustration as bg, type EmptyStateInstance as bh, type EmptyStateOptions as bi, type Expiry as bj, type FileChange as bk, type FileEntry as bl, type FileExplorerInstance as bm, type FileExplorerOptions as bn, type FileFamily as bo, type FileSort as bp, type FileView as bq, type FilterBuilderInstance as br, type FilterBuilderOptions as bs, type FilterField as bt, type FilterFieldType as bu, type FilterGroup as bv, type FilterNode as bw, type FilterRule as bx, type FilterValue as by, type HoldConfirmInstance as bz, createStudioDock as c, type TimeInput as c$, type PanelOrientation as c0, type PasswordChecks as c1, type PasswordScore as c2, type PasswordStrengthInstance as c3, type PasswordStrengthOptions as c4, type Placed as c5, type Placement as c6, type PopoverInstance as c7, type PopoverOptions as c8, type ProgressInstance as c9, type Side as cA, type SkeletonAnimation as cB, type SkeletonInstance as cC, type SkeletonOptions as cD, type SkeletonShape as cE, type SlotPickerInstance as cF, type SlotPickerLabels as cG, type SlotPickerOptions as cH, type SlotSource as cI, type SlotValue as cJ, type SortDirection as cK, type SplitSide as cL, type SplitViewInstance as cM, type SplitViewOptions as cN, type StarRatingInstance as cO, type StarRatingOptions as cP, type StatCardInstance as cQ, type StatCardOptions as cR, type StudioDockInstance as cS, type StudioDockOptions as cT, type StudioDockState as cU, type StudioDockView as cV, TIMING as cW, type TagInputInstance as cX, type TagInputOptions as cY, type TimeFieldInstance as cZ, type TimeFieldOptions as c_, type ProgressOptions as ca, type ProgressVariant as cb, type QuantityInstance as cc, type QuantityOptions as cd, type QuestionnaireAnswers as ce, type QuestionnaireInstance as cf, type QuestionnaireLabels as cg, type QuestionnaireOptions as ch, type RangeCalendarInstance as ci, type RangeCalendarOptions as cj, type RangeSliderInstance as ck, type RangeSliderOptions as cl, type RangeValue as cm, type ResizablePanelInstance as cn, type ResizablePanelOptions as co, type RevealOptions as cp, type RevealSpeed as cq, type Rgba as cr, type RichCommand as cs, type RichTextEditorInstance as ct, type RichTextEditorOptions as cu, type RowChange as cv, type RowId as cw, STRENGTH_LABELS as cx, type ScratchCardInstance as cy, type ScratchCardOptions as cz, createPagination as d, searchTree as d$, type TimelineEvent as d0, type TimelineInstance as d1, type TimelineOptions as d2, type TimelineStatus as d3, type TooltipInstance as d4, type TooltipOptions as d5, type TrailerInstance as d6, type TrailerOptions as d7, type TreeNode as d8, type TreeViewInstance as d9, findNode as dA, formatBytes as dB, formatColor as dC, formatNumber as dD, formatSize as dE, getChannel as dF, hasConditions as dG, hsvToRgb as dH, jsonPath as dI, linkDomain as dJ, luhn as dK, luminance as dL, matchesFilter as dM, normaliseSizes as dN, parseColor as dO, parseExpiry as dP, place as dQ, rangeKeys as dR, rangeLength as dS, readAnswers as dT, relativeTime as dU, revealFrom as dV, rgbToHsv as dW, safeHref as dX, safeImage as dY, sanitizeHtml as dZ, scorePassword as d_, type TreeViewOptions as da, type VirtualKey as db, type VirtualListInstance as dc, type VirtualListOptions as dd, type VirtualRange as de, type VirtualScrollOptions as df, type VirtualSizes as dg, acceptsFile as dh, bandDuration as di, cardLength as dj, channelText as dk, checkStates as dl, codeLines as dm, createDialog as dn, createMenu as dp, createSizes as dq, cvcLength as dr, dateTimeKey as ds, dayKey as dt, dayLabel as du, describeAccept as dv, describeFilter as dw, detectBrand as dx, emptyFilter as dy, fileFamily as dz, createHoverCard as e, setChannel as e0, skeletonBones as e1, sortEntries as e2, toDate as e3, toDateTimeValue as e4, toHex as e5, toHsva as e6, toRange as e7, toggleCheck as e8, createInputOtp as f, createCalendar as g, createSlotPicker as h, createCreditCard as i, createCommandSearch as j, createHoldConfirm as k, createImagePreview as l, createNotificationBell as m, createPasswordStrength as n, createScratchCard as o, createStarRating as p, createAttachment as q, createSkeleton as r, createQuestionnaire as s, createCodeBlock as t, createContextMenu as u, createLinkPreview as v, createProgress as w, createRangeSlider as x, createChart as y, createColorSlider as z };