@yewdiel21/motion-kit 0.10.0 → 0.15.0

package/dist/reveal-BfyKKsw4.d.ts

@@ -0,0 +1,2474 @@
+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. A pill
+ * ([data-mk-pagination-indicator]) glides under the current page on Melonmind's
+ * swing; when the window moves, the numbers that stay slide to their new place
+ * and the new ones pop in out of a blur; the arrows press and nudge their way.
+ */
+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.
+ * It grows out of the trigger's centre (--mk-hover-origin-x) and, when the
+ * pointer leaves, folds back into it (data-mk-closing, .22 s) before hiding.
+ */
+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;
+        strip?: string;
+        picture?: string;
+    };
+    /** A strip of thumbnails under the picture (default true; hidden on phones and with one picture). */
+    strip?: boolean;
+    /** 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' | 'composed';
+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>;
+    /** Per-series mark in a composed chart (default line). */
+    type?: 'line' | 'area' | 'bar';
+    /** An area's lower boundary; values is the upper boundary. Nulls leave gaps. */
+    lowerValues?: 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;
+    /** Folder and page icons (default false); a node's own `icon` still wins. */
+    icons?: boolean;
+    /** Rows can be dragged into another branch (default false). */
+    draggable?: boolean;
+    /** A node was dropped into a branch (the tree has moved it). */
+    onMove?: (node: TreeNode, into: TreeNode) => 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;
+
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    /** A heading the option sits under (an <optgroup>). */
+    group?: string;
+}
+interface SelectOptions {
+    /** The choices; without them, the authored <select> gives them. */
+    options?: SelectOption[];
+    value?: string;
+    /** Form name of the select it builds (an authored one keeps its own). */
+    name?: string;
+    /** Accessible name; the button reads "<label>: <chosen>". */
+    label?: string;
+    /** Text while nothing is chosen (default: the empty option's text, else 'Elige…'). */
+    placeholder?: string;
+    disabled?: boolean;
+    onChange?: (value: string) => void;
+}
+interface SelectInstance extends Instance {
+    setValue(value: string, notify?: boolean): void;
+    setOptions(options: SelectOption[]): void;
+    /** Read the select's options again (changes to them are also noticed on their own). */
+    refresh(): void;
+    open(): void;
+    close(): void;
+    readonly value: string;
+}
+declare function createSelect(root: HTMLElement | null, options?: SelectOptions): SelectInstance;
+
+interface AddToCartOptions {
+    /** Where the box goes: an element, a selector, or (default) the first visible [data-mk-cart-target]. */
+    target?: HTMLElement | string;
+    /** The picture packed: an element, a selector, or (default) the [data-mk-cart-image] of the [data-mk-cart-item] around the button. */
+    image?: HTMLElement | string;
+    /** Items each click adds (default 1). */
+    quantity?: number;
+    /** The cart's count to start from (default: the number in the target's [data-mk-cart-count], else 0). */
+    count?: number;
+    /** Announced after a box lands (default 'Añadido al carrito'). */
+    label?: string;
+    /** A click: the new count (right away). */
+    onAdd?: (count: number) => void;
+    /** A box landed in the cart. */
+    onLand?: (count: number) => void;
+}
+interface AddToCartInstance extends Instance {
+    /** Send a box, as a click does. */
+    add(): void;
+    setCount(count: number): void;
+    readonly count: number;
+}
+declare function createAddToCart(root: HTMLElement | null, options?: AddToCartOptions): AddToCartInstance;
+
+interface ScrollIslandOptions {
+    /** Headings that name the sections (default 'h2, h3'); false: only the percentage. */
+    sections?: string | false;
+    /** How near the edge, in px, the pointer turns the bar into the island (default 56). */
+    reach?: number;
+    /** ms the bar stays after scrolling stops (default 900). */
+    idle?: number;
+    /** Follow the page's scroll (default: when the root is <html> or <body>). */
+    page?: boolean;
+    /** The current section changed (its heading's text, or null before the first). */
+    onSection?: (section: string | null) => void;
+}
+interface ScrollIslandInstance extends Instance {
+    /** Measure again (after the content changed size). */
+    refresh(): void;
+}
+declare function createScrollIsland(root: HTMLElement | null, options?: ScrollIslandOptions): ScrollIslandInstance;
+
+/**
+ * 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 DataAction as a$, createSelect as a0, createAddToCart as a1, createScrollIsland as a2, type RevealHandle as a3, type DateInput as a4, type ActivityActor as a5, type ActivityFeedInstance as a6, type ActivityFeedOptions as a7, type ActivityItem as a8, type ActivityKind as a9, type ChartTooltipInstance as aA, type ChartTooltipOptions as aB, type ChartTooltipSeries as aC, type ChartType as aD, type CheckState as aE, type CodeBlockInstance as aF, type CodeBlockOptions as aG, type ColorAreaInstance as aH, type ColorAreaOptions as aI, type ColorChannel as aJ, type ColorFieldInstance as aK, type ColorFieldOptions as aL, type ColorFormat as aM, type ColorPickerInstance as aN, type ColorPickerOptions as aO, type ColorSliderInstance as aP, type ColorSliderOptions as aQ, type CommandItem as aR, type CommandSearchInstance as aS, type CommandSearchOptions as aT, type ContextMenuInstance as aU, type ContextMenuOptions as aV, type CreditCardField as aW, type CreditCardInstance as aX, type CreditCardLabels as aY, type CreditCardOptions as aZ, type CreditCardValues as a_, type AddToCartInstance as aa, type AddToCartOptions as ab, type AttachmentFile as ac, type AttachmentInstance as ad, type AttachmentLabels as ae, type AttachmentOptions as af, type AttachmentRejectCode as ag, type AttachmentRejection as ah, type AttachmentStatus as ai, BRAND_LABELS as aj, type BreadcrumbInstance as ak, type BreadcrumbItem as al, type BreadcrumbOptions as am, CHANNEL_LABELS as an, type CalendarEvent as ao, type CalendarEventStatus as ap, type CalendarInstance as aq, type CalendarLabels as ar, type CalendarOptions as as, type CalendarRange as at, type CalendarView as au, type CardBrand as av, type ChartInstance as aw, type ChartOptions as ax, type ChartPoint as ay, type ChartSeries as az, createQuantity as b, type MultiSelectOptions as b$, type DataColumn as b0, type DataColumnType as b1, type DataRow as b2, type DataSort as b3, type DataTableInstance as b4, type DataTableOptions as b5, type DateRange as b6, type DateRangePickerInstance as b7, type DateRangePickerOptions as b8, type DateTimePickerInstance as b9, type FilterGroup as bA, type FilterNode as bB, type FilterRule as bC, type FilterValue as bD, type HoldConfirmInstance as bE, type HoldConfirmOptions as bF, type HoverCardInstance as bG, type HoverCardOptions as bH, type Hsla as bI, type Hsva as bJ, type ImagePreviewInstance as bK, type ImagePreviewOptions as bL, type InputOtpInstance as bM, type InputOtpOptions as bN, type JsonType as bO, type JsonViewerInstance as bP, type JsonViewerOptions as bQ, type LinkPreviewInstance as bR, type LinkPreviewOptions as bS, type LinkPreviewVariant as bT, type LoadingButtonInstance as bU, type LoadingButtonOptions as bV, type LoadingState as bW, type MenuInstance as bX, type MenuOptions as bY, type MultiSelectInstance as bZ, type MultiSelectOption as b_, type DateTimePickerOptions as ba, type DialogInstance as bb, type DialogLabels as bc, type DialogOptions as bd, type DialogPlacement as be, type DialogVariant as bf, type EditableColumn as bg, type EditableTableInstance as bh, type EditableTableOptions as bi, type EditorKind as bj, type EmptyAction as bk, type EmptyIllustration as bl, type EmptyStateInstance as bm, type EmptyStateOptions as bn, type Expiry as bo, type FileChange as bp, type FileEntry as bq, type FileExplorerInstance as br, type FileExplorerOptions as bs, type FileFamily as bt, type FileSort as bu, type FileView as bv, type FilterBuilderInstance as bw, type FilterBuilderOptions as bx, type FilterField as by, type FilterFieldType as bz, createStudioDock as c, type StatCardOptions as c$, type NotificationBellInstance as c0, type NotificationBellOptions as c1, OPERATORS as c2, type PaginationInstance as c3, type PaginationOptions as c4, type PanelOrientation as c5, type PasswordChecks as c6, type PasswordScore as c7, type PasswordStrengthInstance as c8, type PasswordStrengthOptions as c9, type RowChange as cA, type RowId as cB, STRENGTH_LABELS as cC, type ScratchCardInstance as cD, type ScratchCardOptions as cE, type ScrollIslandInstance as cF, type ScrollIslandOptions as cG, type SelectInstance as cH, type SelectOption as cI, type SelectOptions as cJ, type Side as cK, type SkeletonAnimation as cL, type SkeletonInstance as cM, type SkeletonOptions as cN, type SkeletonShape as cO, type SlotPickerInstance as cP, type SlotPickerLabels as cQ, type SlotPickerOptions as cR, type SlotSource as cS, type SlotValue as cT, type SortDirection as cU, type SplitSide as cV, type SplitViewInstance as cW, type SplitViewOptions as cX, type StarRatingInstance as cY, type StarRatingOptions as cZ, type StatCardInstance as c_, type Placed as ca, type Placement as cb, type PopoverInstance as cc, type PopoverOptions as cd, type ProgressInstance as ce, type ProgressOptions as cf, type ProgressVariant as cg, type QuantityInstance as ch, type QuantityOptions as ci, type QuestionnaireAnswers as cj, type QuestionnaireInstance as ck, type QuestionnaireLabels as cl, type QuestionnaireOptions as cm, type RangeCalendarInstance as cn, type RangeCalendarOptions as co, type RangeSliderInstance as cp, type RangeSliderOptions as cq, type RangeValue as cr, type ResizablePanelInstance as cs, type ResizablePanelOptions as ct, type RevealOptions as cu, type RevealSpeed as cv, type Rgba as cw, type RichCommand as cx, type RichTextEditorInstance as cy, type RichTextEditorOptions as cz, createPagination as d, rangeKeys as d$, type StudioDockInstance as d0, type StudioDockOptions as d1, type StudioDockState as d2, type StudioDockView as d3, TIMING as d4, type TagInputInstance as d5, type TagInputOptions as d6, type TimeFieldInstance as d7, type TimeFieldOptions as d8, type TimeInput as d9, createSizes as dA, cvcLength as dB, dateTimeKey as dC, dayKey as dD, dayLabel as dE, describeAccept as dF, describeFilter as dG, detectBrand as dH, emptyFilter as dI, fileFamily as dJ, findNode as dK, formatBytes as dL, formatColor as dM, formatNumber as dN, formatSize as dO, getChannel as dP, hasConditions as dQ, hsvToRgb as dR, jsonPath as dS, linkDomain as dT, luhn as dU, luminance as dV, matchesFilter as dW, normaliseSizes as dX, parseColor as dY, parseExpiry as dZ, place as d_, type TimelineEvent as da, type TimelineInstance as db, type TimelineOptions as dc, type TimelineStatus as dd, type TooltipInstance as de, type TooltipOptions as df, type TrailerInstance as dg, type TrailerOptions as dh, type TreeNode as di, type TreeViewInstance as dj, type TreeViewOptions as dk, type VirtualKey as dl, type VirtualListInstance as dm, type VirtualListOptions as dn, type VirtualRange as dp, type VirtualScrollOptions as dq, type VirtualSizes as dr, acceptsFile as ds, bandDuration as dt, cardLength as du, channelText as dv, checkStates as dw, codeLines as dx, createDialog as dy, createMenu as dz, createHoverCard as e, rangeLength as e0, readAnswers as e1, relativeTime as e2, revealFrom as e3, rgbToHsv as e4, safeHref as e5, safeImage as e6, sanitizeHtml as e7, scorePassword as e8, searchTree as e9, setChannel as ea, skeletonBones as eb, sortEntries as ec, toDate as ed, toDateTimeValue as ee, toHex as ef, toHsva as eg, toRange as eh, toggleCheck as ei, 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 };