@reservi/calendar 1.4.0

package/dist/index.d.ts

@@ -0,0 +1,1383 @@
+import { ComponentChildren } from 'preact';
+import { CSSProperties } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { ReactNode } from 'react';
+import { ReadonlySignal } from '@preact/signals-core';
+import { RefAttributes } from 'react';
+
+/** Convierte un `EventDef` del núcleo en el evento que ve el anfitrión. */
+export declare function adaptEvent(def: EventDef): RsvEventApi;
+
+/** Vista + rango visible, con fechas nativas. */
+export declare function adaptView(spec: ViewSpec, range?: DateRange, title?: string): RsvViewApi;
+
+/** Opciones del calendario menos lo que en React se expresa como props. */
+declare type BaseOptions = Omit<ReserviCalendarOptions, "slots" | "hooks" | "hostBridge">;
+
+declare interface BusinessHoursInput {
+    /** Días laborables, 0 = domingo … 6 = sábado. */
+    daysOfWeek?: number[];
+    startTime?: string;
+    endTime?: string;
+}
+
+/**
+ * API pública del calendario y orquestador del dominio. Mantiene el estado en
+ * signals (fecha y vista actuales) y deriva el ViewModel bajo demanda.
+ */
+export declare class CalendarApi {
+    private readonly dl;
+    private readonly registry;
+    private readonly store;
+    private readonly emitter;
+    private readonly options;
+    private readonly sources;
+    private httpClient;
+    private readonly pluginTeardowns;
+    private readonly currentDate;
+    private readonly viewType;
+    private readonly selection;
+    private readonly resourceTree;
+    private readonly collapsed;
+    private readonly _selectedEventIds;
+    private disposeEffect;
+    /**
+     * Versión de las opciones. `getViewModel()` la lee para que `setOption`/
+     * `render()` invaliden el `computed` (las opciones son un objeto mutable y
+     * los signals no pueden rastrearlo).
+     */
+    private readonly optionsVersion;
+    private adapter;
+    private rootEl;
+    /** Profundidad de `batchRendering` (>0 ⇒ se aplazan las invalidaciones). */
+    private batchDepth;
+    private batchDirty;
+    /** Ids de eventos seleccionados (bulk ops). Reactivo: úsalo con `.value` en la UI. */
+    readonly selectedEventIds: ReadonlySignal<ReadonlySet<string>>;
+    /**
+     * ViewModel reactivo: se recalcula solo cuando cambian la fecha, la vista o
+     * los eventos. La capa de UI (Preact) lee `.value` y re-renderiza de forma
+     * granular.
+     */
+    readonly viewModel: ReadonlySignal<ViewModel>;
+    constructor(options: CalendarOptions, datePort?: DatePort, http?: HttpPort);
+    /** Cliente HTTP perezoso (solo se crea/importa nexa si se usa un feed). */
+    private getHttp;
+    /** Rango visible actual como argumento de fetch para las fuentes. */
+    private fetchArg;
+    /** Eventos combinados: array base (`events`/`addEvent`) + fuentes. */
+    private allEvents;
+    getDate(): RsvDate;
+    gotoDate(date: Parameters<DatePort["from"]>[0]): this;
+    today(): this;
+    private step;
+    prev(): this;
+    next(): this;
+    incrementDate(duration: Duration): this;
+    changeView(type: string): this;
+    getView(): {
+        type: string;
+        spec: ViewSpec;
+    };
+    /** ¿Está registrada esta vista? (para navegación segura, navLinks…). */
+    hasView(type: string): boolean;
+    private currentSpec;
+    addEvent(input: EventInput): EventDef;
+    getEventById(id: string): EventDef | undefined;
+    getEvents(): EventDef[];
+    removeAllEvents(): void;
+    /**
+     * Re-pide los eventos. Sin argumento, refresca todas las fuentes para el rango
+     * visible. Con un array, además reemplaza los eventos base (`events`).
+     */
+    refetchEvents(events?: EventInput[]): void;
+    /** Registra una fuente (array/función/feed) y la pide para el rango actual. */
+    addEventSource(input: EventSourceInput): EventSource_2;
+    /** Fuentes registradas (no incluye los `events` base). */
+    getEventSources(): EventSource_2[];
+    /** Elimina una fuente por id y sus eventos. */
+    removeEventSource(id: string): void;
+    removeAllEventSources(): void;
+    /**
+     * Actualiza las fechas de un evento (lo usan drag y resize). Dispara
+     * `eventChange`. Devuelve el evento actualizado o undefined si no existe.
+     */
+    updateEventDates(id: string, start: RsvDate, end: RsvDate | null): EventDef | undefined;
+    /** ¿Puede colocarse el evento en [start, end)? Aplica overlap/constraint/allow. */
+    canPlace(id: string, start: RsvDate, end: RsvDate | null): boolean;
+    /**
+     * Mueve/redimensiona un evento validando reglas (overlap/constraint/allow).
+     * Devuelve true si se aplicó; false si la colocación no es válida.
+     */
+    moveEvent(id: string, start: RsvDate, end: RsvDate | null): boolean;
+    select(start: Parameters<DatePort["from"]>[0], end: Parameters<DatePort["from"]>[0]): this;
+    unselect(): this;
+    getSelection(): Selection_2 | null;
+    /** Reemplaza la selección de eventos por este conjunto de ids. */
+    selectEvents(ids: string[]): this;
+    /** Alterna un evento dentro/fuera de la selección. */
+    toggleEventSelection(id: string): this;
+    clearEventSelection(): this;
+    getSelectedEventIds(): string[];
+    /** Elimina un evento por id (y de la selección, si la tenía). */
+    removeEvent(id: string): boolean;
+    /** Elimina todos los eventos actualmente seleccionados y limpia la selección. */
+    removeSelectedEvents(): void;
+    /** Filas de recursos aplanadas según el estado de expansión. */
+    getResourceRows(): ResourceRow[];
+    /** Mueve un evento a otro recurso (drag entre recursos). Dispara `eventChange`. */
+    moveEventToResource(id: string, resourceId: string): EventDef | undefined;
+    /** Colapsa/expande un recurso (alterna). */
+    toggleResource(id: string): this;
+    on<K extends keyof CalendarEvents>(name: K, handler: (arg: CalendarEvents[K]) => void): () => void;
+    off<K extends keyof CalendarEvents>(name: K, handler: (arg: CalendarEvents[K]) => void): void;
+    trigger<K extends keyof CalendarEvents>(name: K, arg: CalendarEvents[K]): void;
+    getOption<K extends keyof CalendarOptions>(key: K): CalendarOptions[K];
+    setOption<K extends keyof CalendarOptions>(key: K, value: CalendarOptions[K]): this;
+    /** Aplica varias opciones de una vez (una sola invalidación y un solo datesSet). */
+    setOptions(patch: Partial<CalendarOptions>): this;
+    /** Marca el ViewModel como sucio (respeta `batchRendering`). */
+    private invalidate;
+    /** Fuerza un re-render de la vista (equivalente a `render()` de FullCalendar). */
+    render(): this;
+    /**
+     * Agrupa varias mutaciones en un solo re-render. Compatible con
+     * `batchRendering` de FullCalendar.
+     */
+    batchRendering(fn: () => void): void;
+    /** Instala (o retira, con `null`) el adaptador de vista. */
+    setViewAdapter(adapter: CalendarViewAdapter | null): void;
+    /** Elemento raíz del calendario, o null si aún no se ha montado. */
+    get el(): HTMLElement | null;
+    /** Registra el elemento raíz (lo llama la capa de UI al montar). */
+    setRootEl(el: HTMLElement | null): void;
+    /** Desplaza el cuerpo de la vista hasta esa hora. No-op si la vista no scrollea. */
+    scrollToTime(time: string): this;
+    /** Hora visible en el borde superior del cuerpo de la vista, o null. */
+    getScrollTime(): string | null;
+    /** Recalcula medidas del layout. No-op: el layout de Reservi es puro CSS. */
+    updateSize(): this;
+    /** Opciones globales + overrides de `options.viewOverrides[viewType]` (si hay). */
+    private effectiveOptions;
+    /** Como `getOption`, pero resuelto con el override de `views` de esa vista. */
+    getEffectiveOption<K extends keyof CalendarOptions>(key: K, viewType?: string): CalendarOptions[K];
+    getViewModel(): ViewModel;
+    /** "Ahora" del calendario: la opción `now` si se dio, si no el reloj real. */
+    private nowDate;
+    /** Primer día de la semana efectivo: opción explícita o el del locale. */
+    private firstDay;
+    /** Construye un Date UTC a partir de los componentes (independiente del host). */
+    private toUtc;
+    /** Título de la toolbar, localizado vía Intl (en UTC para ser determinista). */
+    private formatTitle;
+    private emitDatesSet;
+    /** Libera recursos (efectos de signals). */
+    destroy(): void;
+}
+
+/** Mapa de eventos emitibles (crece por fase). */
+declare interface CalendarEvents extends Record<string, unknown> {
+    datesSet: {
+        range: DateRange;
+        view: ViewSpec;
+    };
+    eventsSet: EventDef[];
+    eventClick: {
+        event: EventDef;
+        el?: HTMLElement;
+    };
+    /** `allDay` distingue el clic en la franja de todo el día del clic en un slot. */
+    dateClick: {
+        date: RsvDate;
+        allDay?: boolean;
+    };
+    eventChange: {
+        event: EventDef;
+    };
+    eventDrop: {
+        event: EventDef;
+    };
+    eventResize: {
+        event: EventDef;
+    };
+    select: {
+        start: RsvDate;
+        end: RsvDate;
+    };
+    unselect: Record<string, never>;
+    navLinkDay: {
+        date: RsvDate;
+    };
+    moreLinkClick: {
+        date: RsvDate;
+        allEvents: EventDef[];
+        hiddenEvents: EventDef[];
+    };
+    loading: {
+        isLoading: boolean;
+    };
+    eventSelectionChange: {
+        ids: string[];
+    };
+}
+
+/** Opciones de calendario (subconjunto de Fase 1; crece por fase). */
+export declare interface CalendarOptions {
+    /** Vista inicial, p. ej. "dayGridMonth". */
+    initialView: string;
+    /** Fecha inicial (por defecto: hoy). */
+    initialDate?: DateLike;
+    /** Sobreescribe "ahora" (útil para tests y demos deterministas). */
+    now?: DateLike;
+    /** Plugins que aportan vistas/comportamientos. */
+    plugins?: PluginDef[];
+    /** Eventos iniciales (array). */
+    events?: EventInput[];
+    /**
+     * Fuentes de eventos adicionales: arrays, funciones `(rango)=>eventos|Promise`
+     * o feeds JSON remotos (vía nexa). Se combinan con `events`.
+     */
+    eventSources?: EventSourceInput[];
+    /**
+     * Re-pedir las fuentes dinámicas (función/feed) al cambiar el rango visible
+     * (def. true). Las fuentes de array nunca se re-piden.
+     */
+    lazyFetching?: boolean;
+    /**
+     * Transforma cada evento (de `events` y de las fuentes) antes de normalizarlo.
+     * Útil para remapear payloads remotos al formato de evento.
+     */
+    eventDataTransform?: (input: EventInput) => EventInput;
+    /** Recursos (Scheduler): jerarquía por `children` o `parentId`. */
+    resources?: ResourceInput[];
+    /** Recursos inicialmente expandidos (def. true). */
+    resourcesInitiallyExpanded?: boolean;
+    /** Orden de recursos por campo ("title", "id" o "-title" para descendente). */
+    resourceOrder?: string;
+    /** Ancho del área de recursos en las vistas de recurso (def. "30%"). */
+    resourceAreaWidth?: string;
+    /** Primer día de la semana: 0 = domingo (def.) … 6 = sábado. */
+    firstDay?: number;
+    /** Mostrar fin de semana (def. true). Equivale a hiddenDays=[0,6] si es false. */
+    weekends?: boolean;
+    /** Días a ocultar (0=domingo…6=sábado). Tiene prioridad sobre weekends. */
+    hiddenDays?: number[];
+    /** Mes: forzar 6 semanas siempre (def. false). */
+    fixedWeekCount?: boolean;
+    /** Mes: mostrar días de meses adyacentes (def. true). */
+    showNonCurrentDates?: boolean;
+    /** Mostrar la columna de número de semana (def. false). */
+    weekNumbers?: boolean;
+    /** Cálculo del número de semana: "local" (def.) o "ISO". */
+    weekNumberCalculation?: "local" | "ISO";
+    /** Hace clic-navegables los números/cabeceras de día (van a la vista de día). */
+    navLinks?: boolean;
+    /** Máximo de eventos por celda antes del enlace "+N more". */
+    dayMaxEvents?: number | boolean;
+    /**
+     * Alias de `dayMaxEvents` por compatibilidad con FullCalendar. Si se indica
+     * y `dayMaxEvents` no, se usa este valor.
+     */
+    dayMaxEventRows?: number | boolean;
+    /** Hora mínima visible (def. "00:00"). */
+    slotMinTime?: string;
+    /** Hora máxima visible (def. "24:00"). */
+    slotMaxTime?: string;
+    /** Altura temporal de cada slot, "HH:mm" (def. "00:30"). */
+    slotDuration?: string;
+    /** Cada cuánto se etiqueta el eje, "HH:mm" (def. "01:00"). */
+    slotLabelInterval?: string;
+    /** Mostrar la franja de todo el día (def. true). */
+    allDaySlot?: boolean;
+    /** Mostrar el indicador de "ahora" (def. true). */
+    nowIndicator?: boolean;
+    /**
+     * Hora a la que se desplaza el scroll del cuerpo de timeGrid al montar la
+     * vista y al cambiar de vista/fecha, "HH:mm" o "HH:mm:ss" (def. "06:00").
+     */
+    scrollTime?: string;
+    /** Permite arrastrar/redimensionar eventos (def. false). */
+    editable?: boolean;
+    /** Permite seleccionar rangos por arrastre (def. false). */
+    selectable?: boolean;
+    /** Dibuja un "fantasma" del rango mientras se arrastra la selección (def. false). */
+    selectMirror?: boolean;
+    /** Resolución de ajuste al arrastrar, "HH:mm" (def. "00:15"). */
+    snapDuration?: string;
+    /** Horas laborables (sombreado y posible constraint). */
+    businessHours?: boolean | BusinessHoursInput;
+    /** Permitir solapamiento de eventos al mover/redimensionar (def. true). */
+    eventOverlap?: boolean;
+    /** Restringe eventos a las horas laborables. */
+    eventConstraint?: "businessHours";
+    /** Veto programático al mover/redimensionar un evento. */
+    eventAllow?: (info: EventAllowInfo) => boolean;
+    /** Nombre de un theme pre-hecho (se aplica como data-rsv-theme en el root). */
+    theme?: string;
+    /** Tokens de theme personalizados (se aplican inline como variables CSS). */
+    themeTokens?: Partial<ReserviThemeTokens>;
+    locale?: string;
+    /** Dirección del texto; por defecto se deriva del locale. */
+    direction?: "ltr" | "rtl";
+    /** Zona horaria: "local" (def.), "UTC" o IANA. */
+    timeZone?: string;
+    headerToolbar?: ToolbarOptions | false;
+    /** Alto de cada slot horario en px (mapea a la variable de theme `slotHeight`). */
+    hourHeight?: number;
+    /**
+     * Alto del contenedor raíz: número de px, cualquier longitud CSS o "auto"
+     * (el calendario crece con su contenido). Por defecto no se fija alto.
+     */
+    height?: number | string;
+    /** Formato de la hora mostrada en los eventos (def. 24h "HH:mm"). */
+    eventTimeFormat?: Intl.DateTimeFormatOptions;
+    /** Formato de las etiquetas del eje horario de timeGrid (def. 24h "HH:mm"). */
+    slotLabelFormat?: Intl.DateTimeFormatOptions;
+    /** Formato de la cabecera de día; `false` oculta el texto por defecto. */
+    dayHeaderFormat?: Intl.DateTimeFormatOptions | false;
+    /** Formato de la cabecera de día de la vista lista. */
+    listDayFormat?: Intl.DateTimeFormatOptions | false;
+    /** Formato del texto secundario de la cabecera de día de la vista lista. */
+    listDaySideFormat?: Intl.DateTimeFormatOptions | false;
+    /**
+     * Formato del título de la toolbar: opciones de `Intl.DateTimeFormat`, o una
+     * función que recibe el rango visible y devuelve el título ya formateado.
+     */
+    titleFormat?: Intl.DateTimeFormatOptions | ((range: DateRange) => string);
+    /**
+     * Overrides de cualquier opción anterior, por tipo de vista (p. ej.
+     * `{ timeGridDay: { slotDuration: "00:15" } }`). Se mergean sobre las
+     * opciones globales solo mientras esa vista está activa.
+     */
+    viewOverrides?: Record<string, Partial<CalendarOptions>>;
+    /**
+     * Atajos de teclado configurables para navegar/activar un evento enfocado
+     * (por defecto: flechas para mover, Enter/espacio para activar).
+     */
+    keyboardShortcuts?: Partial<Record<KeyboardAction, string[]>>;
+}
+
+/**
+ * Adaptador que instala la capa de UI para las operaciones que necesitan DOM
+ * (scroll, medidas). El núcleo sigue siendo agnóstico: si no hay adaptador
+ * instalado, estas operaciones son no-ops seguras.
+ */
+export declare interface CalendarViewAdapter {
+    /** Desplaza el cuerpo de la vista hasta esa hora ("HH:mm" / "HH:mm:ss"). */
+    scrollToTime?(time: string): void;
+    /** Hora ("HH:mm:ss") en el borde superior del área visible, o null. */
+    getScrollTime?(): string | null;
+    /** Fuerza un recálculo de medidas del layout. */
+    updateSize?(): void;
+}
+
+export declare interface DateClickArg {
+    date: Date;
+    dateStr: string;
+    allDay: boolean;
+    view: RsvViewApi;
+}
+
+declare type DateLike = string | number | Date;
+
+declare interface DatePort {
+    /** Crea una fecha a partir de ISO string, epoch ms o Date nativo. */
+    from(input: DateLike): RsvDate;
+    /** Instante actual. */
+    now(): RsvDate;
+    add(date: RsvDate, duration: Duration): RsvDate;
+    subtract(date: RsvDate, duration: Duration): RsvDate;
+    startOf(date: RsvDate, unit: DateUnit): RsvDate;
+    endOf(date: RsvDate, unit: DateUnit): RsvDate;
+    /** Día de la semana, 0 = domingo … 6 = sábado (convención FullCalendar). */
+    dayOfWeek(date: RsvDate): number;
+    /** Año (p. ej. 2026). */
+    year(date: RsvDate): number;
+    /** Mes 1–12. */
+    month(date: RsvDate): number;
+    /** Día del mes 1–31. */
+    dayOfMonth(date: RsvDate): number;
+    /** Hora 0–23. */
+    hour(date: RsvDate): number;
+    /** Minuto 0–59. */
+    minute(date: RsvDate): number;
+    isBefore(a: RsvDate, b: RsvDate): boolean;
+    isAfter(a: RsvDate, b: RsvDate): boolean;
+    isSame(a: RsvDate, b: RsvDate, unit?: DateUnit): boolean;
+    /** ¿Mismo día natural? Compara año/mes/día (robusto frente a zona horaria). */
+    isSameDay(a: RsvDate, b: RsvDate): boolean;
+    /** ¿`date` está en [start, end)? */
+    isBetween(date: RsvDate, start: RsvDate, end: RsvDate): boolean;
+    /** Diferencia entera de `b - a` en la unidad dada. */
+    diff(a: RsvDate, b: RsvDate, unit: DateUnit): number;
+    range(start: RsvDate, end: RsvDate): RsvRange;
+    /** Lista de días (inicio de cada día) que solapan el rango [start, end). */
+    eachDayOfRange(start: RsvDate, end: RsvDate): RsvDate[];
+    format(date: RsvDate, pattern: string): string;
+    locale(date: RsvDate, locale: string): RsvDate;
+    timezone(date: RsvDate, timeZone: string): RsvDate;
+    toISOString(date: RsvDate): string;
+    toDate(date: RsvDate): Date;
+    valueOf(date: RsvDate): number;
+}
+
+/** Rango de fechas calculado para la vista actual. */
+declare interface DateRange {
+    /** Inicio del rango visible (puede incluir días de meses adyacentes). */
+    readonly activeStart: RsvDate;
+    /** Fin (exclusivo) del rango visible. */
+    readonly activeEnd: RsvDate;
+    /** Inicio del periodo "actual" (p. ej. el día 1 del mes). */
+    readonly currentStart: RsvDate;
+    /** Fin (exclusivo) del periodo actual. */
+    readonly currentEnd: RsvDate;
+}
+
+export declare interface DatesSetArg {
+    start: Date;
+    end: Date;
+    startStr: string;
+    endStr: string;
+    view: RsvViewApi;
+}
+
+/**
+ * DatePort — puerto de salida del dominio para TODA la lógica de fechas.
+ *
+ * El dominio depende SOLO de esta interfaz (DIP). La implementación concreta
+ * vive en `core/datelib` (adaptador sobre @bereasoftware/time-guard). Esto
+ * permite inyectar un fake determinista en los tests y aísla la dependencia
+ * de la librería de fechas en un único punto (ver STRUCTURE.md §3b).
+ */
+/** Unidad de tiempo para startOf/endOf/diff. */
+declare type DateUnit = "year" | "month" | "week" | "day" | "hour" | "minute" | "second";
+
+/** Argumento del slot de celda de día. */
+declare interface DayCellContentArg {
+    date: Date;
+    dayNumber: number;
+    isToday: boolean;
+    isOther: boolean;
+    view: ViewArg;
+}
+
+declare interface DayGridCell {
+    readonly date: RsvDate;
+    readonly dayOfWeek: number;
+    readonly isToday: boolean;
+    readonly isWeekend: boolean;
+    /** No pertenece al mes "actual" (días de relleno). */
+    readonly isOther: boolean;
+    /** Día laborable (según businessHours). */
+    readonly isBusiness: boolean;
+    /** Día dentro de la selección activa. */
+    readonly isSelected: boolean;
+    /** Eventos visibles ese día (ya recortados por dayMaxEvents). */
+    readonly events: EventDef[];
+    /** Eventos ocultos por el límite (los que cuentan para "+N more"). */
+    readonly hiddenEvents: EventDef[];
+    /** Eventos ocultos por el límite ("+N more"). */
+    readonly moreCount: number;
+}
+
+declare interface DayGridModel {
+    readonly weeks: DayGridWeek[];
+    /** Columnas visibles por semana (7 menos los días ocultos). */
+    readonly columnCount: number;
+}
+
+/**
+ * Plugin DayGrid: registra las vistas de cuadrícula por días. Solo aporta las
+ * especificaciones de vista (datos puros); el renderizado vive en @reservi/preact.
+ */
+export declare const dayGridPlugin: PluginDef;
+
+declare interface DayGridWeek {
+    readonly days: DayGridCell[];
+    /** Número de semana (solo si `weekNumbers` está activo). */
+    readonly weekNumber?: number;
+}
+
+/** Argumento del slot de cabecera de día (nombre del día de la semana). */
+declare interface DayHeaderContentArg {
+    date: Date;
+    text: string;
+    /** Día de la semana, 0 = domingo … 6 = sábado. */
+    dayOfWeek: number;
+    /** Día del mes (1–31). */
+    dayNumber: number;
+    isToday: boolean;
+    view: ViewArg;
+}
+
+/** Helper identidad con tipado, para declarar plugins de forma ergonómica. */
+export declare function definePlugin(def: PluginDef): PluginDef;
+
+/**
+ * Helper para definir un theme tipado y reutilizable.
+ * @example const midnight = defineTheme({ bg: "#0b1020", primary: "#7c5cff" })
+ */
+export declare function defineTheme(tokens: Partial<ReserviThemeTokens>): Partial<ReserviThemeTokens>;
+
+/** Implementación de fechas activa por defecto (time-guard). */
+export declare const dl: DatePort;
+
+/** Duración relativa (los campos ausentes valen 0). */
+declare interface Duration {
+    years?: number;
+    months?: number;
+    weeks?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+}
+
+/** Info que recibe el callback `eventAllow` al arrastrar/redimensionar. */
+declare interface EventAllowInfo {
+    start: RsvDate;
+    end: RsvDate | null;
+    event: EventDef;
+}
+
+export declare interface EventChangeArg {
+    event: RsvEventApi;
+    view: RsvViewApi;
+}
+
+export declare interface EventClickArg {
+    event: RsvEventApi;
+    el: HTMLElement | null;
+    view: RsvViewApi;
+}
+
+/** Argumento del slot de contenido de evento. */
+declare interface EventContentArg {
+    event: EventDef;
+    isAllDay: boolean;
+    /** Texto de hora ya formateado (vacío si allDay). */
+    timeText: string;
+    view: ViewArg;
+}
+
+/**
+ * Evento normalizado del dominio: fechas ya parseadas a RsvDate, colores
+ * resueltos y propiedades no estándar movidas a extendedProps.
+ */
+export declare interface EventDef {
+    readonly id: string;
+    readonly groupId: string;
+    readonly title: string;
+    readonly start: RsvDate;
+    readonly end: RsvDate | null;
+    readonly allDay: boolean;
+    readonly url: string;
+    readonly display: EventDisplay;
+    readonly editable: boolean | null;
+    readonly backgroundColor: string;
+    readonly borderColor: string;
+    readonly textColor: string;
+    readonly classNames: string[];
+    readonly resourceIds: string[];
+    /** Definición de recurrencia, o null si es un evento único. */
+    readonly recurrence: RecurrenceDef | null;
+    readonly extendedProps: Record<string, unknown>;
+}
+
+/** Cómo se pinta un evento (compatible con FullCalendar). */
+declare type EventDisplay = "auto" | "block" | "list-item" | "background" | "inverse-background" | "none";
+
+/** Info que recibe una fuente de eventos al pedirle el rango visible. */
+declare interface EventFetchArg {
+    start: RsvDate;
+    end: RsvDate;
+    /** Inicio del rango en ISO (para `startParam` de feeds). */
+    startStr: string;
+    /** Fin (exclusivo) del rango en ISO. */
+    endStr: string;
+}
+
+/** Entrada de evento tal como la da el usuario. */
+export declare interface EventInput {
+    id?: string;
+    groupId?: string;
+    title?: string;
+    start: DateLike;
+    end?: DateLike;
+    allDay?: boolean;
+    url?: string;
+    editable?: boolean;
+    startEditable?: boolean;
+    durationEditable?: boolean;
+    display?: EventDisplay;
+    color?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+    textColor?: string;
+    classNames?: string | string[];
+    /** Recursos (Scheduler). */
+    resourceId?: string;
+    resourceIds?: string[];
+    /** Días de la semana en que se repite, 0 = domingo … 6 = sábado. */
+    daysOfWeek?: number[];
+    /** Hora de inicio de cada repetición, "HH:mm". */
+    startTime?: string;
+    /** Hora de fin de cada repetición, "HH:mm". */
+    endTime?: string;
+    /** Primer día de la recurrencia. */
+    startRecur?: DateLike;
+    /** Último día (exclusivo) de la recurrencia. */
+    endRecur?: DateLike;
+    /** Duración de cada instancia, "HH:mm" (alternativa a end/endTime). */
+    duration?: string;
+    /** Regla RRULE (RFC 5545) como cadena, p. ej. "FREQ=WEEKLY;BYDAY=MO,WE". */
+    rrule?: string;
+    /** Fechas excluidas (ISO) de la recurrencia. */
+    exdate?: string[];
+    /** Cualquier clave no estándar acaba aquí. */
+    extendedProps?: Record<string, unknown>;
+}
+
+/** Handle público de una fuente registrada. */
+declare interface EventSource_2 {
+    readonly id: string;
+}
+
+/** Fuente como función: recibe el rango y devuelve eventos (sync o async). */
+declare type EventSourceFunc = (arg: EventFetchArg) => EventInput[] | Promise<EventInput[]>;
+
+/** Toda forma admisible de fuente de eventos. */
+declare type EventSourceInput = EventInput[] | EventSourceFunc | JsonFeedSource | EventSourceObject;
+
+/** Objeto fuente: envuelve cualquier tipo y añade `id`/`color` por defecto. */
+declare interface EventSourceObject {
+    id?: string;
+    events: EventInput[] | EventSourceFunc | JsonFeedSource;
+    color?: string;
+    /** Cachea la respuesta por rango durante `ttl` ms (aplica a `events` función o feed). */
+    ttl?: number;
+}
+
+/**
+ * Puente para pintar contenido del framework anfitrión dentro del árbol de
+ * Preact. Lo implementan los wrappers (p. ej. `@reservi/react` con portales).
+ */
+declare interface HostBridge {
+    /** Un hueco ha entrado en el DOM: pinta `node` dentro de `el`. */
+    mount(id: string, el: HTMLElement, node: unknown): void;
+    /** El contenido del hueco `id` ha cambiado. */
+    update(id: string, node: unknown): void;
+    /** El hueco `id` ha salido del DOM: libera lo que se pintó en él. */
+    unmount(id: string): void;
+}
+
+/**
+ * Marcador que puede devolver un slot cuando el contenido lo pinta el
+ * framework anfitrión (React, Vue…). La capa Preact NO interpreta `node`:
+ * solo reserva un hueco en el DOM y delega en el `hostBridge`.
+ */
+declare interface HostSlotResult {
+    readonly __rsvHost: true;
+    /** Nodo del framework anfitrión (opaco para esta capa). */
+    readonly node: unknown;
+}
+
+declare interface HttpError {
+    readonly code: string;
+    readonly message: string;
+    readonly status?: number;
+}
+
+declare interface HttpPort {
+    get<T>(url: string, config?: HttpRequestConfig): Promise<HttpResult<T>>;
+    post<T>(url: string, data?: unknown, config?: HttpRequestConfig): Promise<HttpResult<T>>;
+    put<T>(url: string, data?: unknown, config?: HttpRequestConfig): Promise<HttpResult<T>>;
+    patch<T>(url: string, data?: unknown, config?: HttpRequestConfig): Promise<HttpResult<T>>;
+    delete<T>(url: string, config?: HttpRequestConfig): Promise<HttpResult<T>>;
+}
+
+declare interface HttpRequestConfig {
+    /** Parámetros de query string. */
+    query?: Record<string, unknown>;
+    /** Parámetros de ruta (`/users/:id`). */
+    params?: Record<string, string | number>;
+    headers?: Record<string, string>;
+    /** Timeout en ms. */
+    timeout?: number;
+    /** Caché por petición. */
+    cache?: {
+        enabled: boolean;
+        ttlMs: number;
+    };
+    /** Reintentos por petición. */
+    retry?: {
+        maxAttempts: number;
+        backoffMs: number;
+    };
+}
+
+/**
+ * HttpPort — puerto de salida del dominio para TODA la I/O HTTP.
+ *
+ * El dominio (y las fuentes de eventos remotas) dependen solo de esta interfaz.
+ * La implementación concreta vive en `core/http` (adaptador sobre
+ * @bereasoftware/nexa). Conserva el patrón Result monad de nexa: nada de
+ * excepciones para errores HTTP esperados.
+ */
+declare interface HttpResponse<T> {
+    readonly data: T;
+    readonly status: number;
+}
+
+/** Result monad: éxito tipado o error tipado, nunca ambos. */
+declare type HttpResult<T> = {
+    readonly ok: true;
+    readonly value: HttpResponse<T>;
+} | {
+    readonly ok: false;
+    readonly error: HttpError;
+};
+
+/** Fuente como feed remoto (toda la I/O HTTP pasa por la fachada nexa). */
+declare interface JsonFeedSource {
+    id?: string;
+    url: string;
+    /** "json" (def.) espera un array de eventos; "ics" parsea iCalendar. */
+    format?: "json" | "ics";
+    method?: "GET" | "POST";
+    /** Parámetros extra fijos o calculados en cada fetch. */
+    extraParams?: Record<string, unknown> | (() => Record<string, unknown>);
+    /** Nombre del query param para el inicio del rango (def. "start"). */
+    startParam?: string;
+    /** Nombre del query param para el fin del rango (def. "end"). */
+    endParam?: string;
+    headers?: Record<string, string>;
+    /** Color por defecto aplicado a los eventos sin color propio. */
+    color?: string;
+    /** Cachea la respuesta por rango durante `ttl` ms (sin cache si se omite). */
+    ttl?: number;
+}
+
+/** Acciones de teclado configurables sobre un evento enfocado. */
+declare type KeyboardAction = "moveLeft" | "moveRight" | "moveUp" | "moveDown" | "activate";
+
+declare interface ListDay {
+    readonly date: RsvDate;
+    readonly isToday: boolean;
+    readonly events: EventDef[];
+}
+
+declare interface ListModel {
+    /** Solo días con eventos (como FullCalendar list). */
+    readonly days: ListDay[];
+    readonly isEmpty: boolean;
+}
+
+/** Plugin List: vistas de agenda en lista. */
+export declare const listPlugin: PluginDef;
+
+export declare interface MoreLinkClickArg {
+    date: Date;
+    dateStr: string;
+    allEvents: RsvEventApi[];
+    hiddenEvents: RsvEventApi[];
+    view: RsvViewApi;
+}
+
+/** Argumento del slot del botón "+N more" (popover de eventos ocultos). */
+declare interface MoreLinkContentArg {
+    date: Date;
+    moreCount: number;
+    allEvents: EventDef[];
+    hiddenEvents: EventDef[];
+    view: ViewArg;
+}
+
+declare interface MultiMonthEntry {
+    readonly date: RsvDate;
+    readonly dayGrid: DayGridModel;
+}
+
+declare interface MultiMonthModel {
+    readonly months: MultiMonthEntry[];
+}
+
+/** Plugin MultiMonth: rejilla de varios meses (vista de año). */
+export declare const multiMonthPlugin: PluginDef;
+
+declare interface NowIndicator {
+    readonly dayIndex: number;
+    readonly topPct: number;
+}
+
+/**
+ * Definición de un plugin. Aporta vistas, dependencias y un hook de ciclo de
+ * vida `setup`. Open/Closed: añadir funcionalidad = nuevo plugin, sin tocar el core.
+ */
+declare interface PluginDef {
+    readonly name: string;
+    /** Vistas que registra, indexadas por su `type`. */
+    readonly views?: Record<string, ViewSpec>;
+    /** Plugins de los que depende (se cargan antes). */
+    readonly deps?: PluginDef[];
+    /**
+     * Se llama una vez tras montar el calendario, en orden de dependencias.
+     * Recibe la API (navegación, eventos vía `on`/`off`, fuentes…) y puede
+     * devolver una función de limpieza que se ejecuta al destruir.
+     */
+    readonly setup?: (api: CalendarApi) => PluginTeardown;
+}
+
+/** Función de limpieza opcional devuelta por `setup`. */
+declare type PluginTeardown = void | (() => void);
+
+export declare interface ReactDayCellContentArg {
+    date: Date;
+    dayNumber: number;
+    isToday: boolean;
+    isOther: boolean;
+    view: RsvViewApi;
+}
+
+export declare interface ReactDayHeaderContentArg {
+    date: Date;
+    text: string;
+    dayOfWeek: number;
+    dayNumber: number;
+    isToday: boolean;
+    view: RsvViewApi;
+}
+
+export declare interface ReactEventContentArg {
+    event: RsvEventApi;
+    isAllDay: boolean;
+    timeText: string;
+    view: RsvViewApi;
+}
+
+export declare interface ReactMoreLinkContentArg {
+    date: Date;
+    moreCount: number;
+    allEvents: RsvEventApi[];
+    hiddenEvents: RsvEventApi[];
+    view: RsvViewApi;
+}
+
+export declare interface ReactSlotLabelContentArg {
+    text: string;
+    minutes: number;
+    isMajor: boolean;
+    view: RsvViewApi;
+}
+
+declare type RecurrenceDef = SimpleRecurrence | RRuleRecurrence;
+
+/**
+ * Componente React de Reservi Calendar. API deliberadamente compatible con
+ * `@fullcalendar/react`: mismos nombres de opciones, callbacks como props,
+ * `ref.getApi()` y render props que devuelven JSX.
+ *
+ * Internamente monta la capa agnóstica (Preact) y pinta los render props en el
+ * árbol de React mediante portales, así que el contenido de los eventos
+ * conserva el contexto de React (stores, i18n, theme…).
+ */
+export declare const ReserviCalendar: ForwardRefExoticComponent<ReserviCalendarProps & RefAttributes<ReserviCalendarRef>>;
+
+/** Opciones de la capa Preact = opciones de núcleo + presentación. */
+export declare interface ReserviCalendarOptions extends CalendarOptions {
+    slots?: ReserviSlots;
+    hooks?: ReserviHooks;
+    classNames?: ReserviClassNames;
+    /**
+     * Puente de render del framework anfitrión. Lo inyecta el wrapper; no es
+     * necesario configurarlo a mano en uso vanilla/Preact.
+     */
+    hostBridge?: HostBridge;
+    /**
+     * Vistas a mostrar como pestañas en la segunda fila de la toolbar
+     * (p. ej. ["dayGridMonth", "timeGridWeek", "listWeek"]). Si se omite, se
+     * derivan de los tokens de `headerToolbar`; si tampoco hay, no se muestra la fila.
+     */
+    views?: string[];
+    /**
+     * Callback del botón "Añadir". Solo si se define se renderiza el botón; el
+     * anfitrión decide qué ocurre al pulsarlo (abrir un modal, navegar, etc.).
+     */
+    onAddClick?: () => void;
+    /** Texto del botón "Añadir" (def. "+" sin etiqueta). */
+    addButtonText?: string;
+    /**
+     * Cambia de vista automáticamente al redimensionar el contenedor (p. ej.
+     * mes → lista en mobile). Se evalúa el `breakpoint` más alto que sea
+     * `<= ancho actual` (estilo media query `min-width`).
+     */
+    responsiveViews?: {
+        breakpoint: number;
+        view: string;
+    }[];
+}
+
+export declare interface ReserviCalendarProps extends BaseOptions {
+    eventClick?: (arg: EventClickArg) => void;
+    dateClick?: (arg: DateClickArg) => void;
+    select?: (arg: SelectArg) => void;
+    unselect?: () => void;
+    datesSet?: (arg: DatesSetArg) => void;
+    eventsSet?: (events: RsvEventApi[]) => void;
+    eventDrop?: (arg: EventChangeArg) => void;
+    eventResize?: (arg: EventChangeArg) => void;
+    eventChange?: (arg: EventChangeArg) => void;
+    moreLinkClick?: (arg: MoreLinkClickArg) => void;
+    navLinkDay?: (arg: {
+        date: Date;
+        dateStr: string;
+    }) => void;
+    loading?: (isLoading: boolean) => void;
+    eventContent?: (arg: ReactEventContentArg) => ReactNode;
+    dayCellContent?: (arg: ReactDayCellContentArg) => ReactNode;
+    dayHeaderContent?: (arg: ReactDayHeaderContentArg) => ReactNode;
+    slotLabelContent?: (arg: ReactSlotLabelContentArg) => ReactNode;
+    moreLinkContent?: (arg: ReactMoreLinkContentArg) => ReactNode;
+    eventDidMount?: (arg: ReactEventContentArg & {
+        el: HTMLElement;
+    }) => void;
+    dayCellDidMount?: (arg: ReactDayCellContentArg & {
+        el: HTMLElement;
+    }) => void;
+    dayHeaderDidMount?: (arg: ReactDayHeaderContentArg & {
+        el: HTMLElement;
+    }) => void;
+    slotLabelDidMount?: (arg: ReactSlotLabelContentArg & {
+        el: HTMLElement;
+    }) => void;
+    /** Se invoca con la API del calendario tras montar. */
+    onReady?: (api: CalendarApi) => void;
+    /** Clase del contenedor host. */
+    className?: string;
+    /** Estilos en línea del contenedor host. */
+    style?: CSSProperties;
+}
+
+/** Handle imperativo: `ref.current.getApi()`, como en `@fullcalendar/react`. */
+export declare interface ReserviCalendarRef {
+    getApi(): CalendarApi | null;
+}
+
+/** Clases por slot, fusionadas con las base. */
+export declare interface ReserviClassNames {
+    root?: string;
+    toolbar?: string;
+    /** Celda de día (dayGrid/multiMonth). */
+    day?: string;
+    event?: string;
+    /** Cabecera de día (nombre del día / columna). */
+    dayHeader?: string;
+    /** Etiqueta del eje horario (timeGrid). */
+    slotLabel?: string;
+}
+
+/**
+ * Hooks de ciclo de vida sobre el DOM ya montado (equivalentes a los
+ * `*DidMount` de FullCalendar). Se invocan UNA vez por elemento del DOM.
+ */
+declare interface ReserviHooks {
+    eventDidMount?: (arg: EventContentArg & {
+        el: HTMLElement;
+    }) => void;
+    dayCellDidMount?: (arg: DayCellContentArg & {
+        el: HTMLElement;
+    }) => void;
+    dayHeaderDidMount?: (arg: DayHeaderContentArg & {
+        el: HTMLElement;
+    }) => void;
+    slotLabelDidMount?: (arg: SlotLabelContentArg & {
+        el: HTMLElement;
+    }) => void;
+}
+
+/**
+ * Slots de render (patrón de "content" de FullCalendar). Cada slot devuelve
+ * contenido Preact, una cadena, o `hostSlot(...)` para delegar en el anfitrión.
+ */
+export declare interface ReserviSlots {
+    eventContent?: (arg: EventContentArg) => SlotResult;
+    dayCellContent?: (arg: DayCellContentArg) => SlotResult;
+    dayHeaderContent?: (arg: DayHeaderContentArg) => SlotResult;
+    /** Personaliza la etiqueta del eje horario (timeGrid). */
+    slotLabelContent?: (arg: SlotLabelContentArg) => SlotResult;
+    /**
+     * Personaliza el contenido del botón "+N more" (dayGrid/multiMonth). El
+     * `<button>` que abre el popover se conserva; el slot solo reemplaza su
+     * contenido interno (mismo patrón que `dayCellContent`).
+     */
+    moreLinkContent?: (arg: MoreLinkContentArg) => SlotResult;
+    /**
+     * Contenido libre al inicio de la toolbar (zona "Filtrar/Personal" del diseño).
+     * El usuario decide qué botones poner y qué hacen; si no se define, no se
+     * renderiza nada en esa zona.
+     */
+    toolbarStart?: () => SlotResult;
+    /**
+     * Contenido libre al final de la toolbar, antes del botón "Añadir".
+     * Útil para acciones extra propias del anfitrión.
+     */
+    toolbarEnd?: () => SlotResult;
+}
+
+/**
+ * Tokens de theme programáticos. Permiten construir un theme personalizado en
+ * JS/TS y aplicarlo inline (sin tocar CSS). Los valores por defecto y los themes
+ * pre-hechos viven en @reservi/theme (CSS). Ver THEMES.md.
+ */
+export declare interface ReserviThemeTokens {
+    bg?: string;
+    surface?: string;
+    border?: string;
+    muted?: string;
+    text?: string;
+    primary?: string;
+    primaryFg?: string;
+    today?: string;
+    event1?: string;
+    event2?: string;
+    event3?: string;
+    event4?: string;
+    event5?: string;
+    eventFg?: string;
+    now?: string;
+    selection?: string;
+    nonbusiness?: string;
+    radius?: string;
+    radiusEvent?: string;
+    slotHeight?: string;
+    fontSans?: string;
+}
+
+declare interface ResourceDayGridColumn {
+    readonly row: ResourceRow;
+    readonly events: EventDef[];
+}
+
+declare interface ResourceDayGridModel {
+    readonly date: RsvDate;
+    readonly columns: ResourceDayGridColumn[];
+}
+
+declare interface ResourceDayGridMonthCell {
+    readonly date: RsvDate;
+    readonly isToday: boolean;
+    /** No pertenece al mes "actual" (días de relleno). */
+    readonly isOther: boolean;
+    readonly columns: ResourceDayGridMonthColumn[];
+}
+
+declare interface ResourceDayGridMonthColumn {
+    readonly row: ResourceRow;
+    /** Eventos visibles ese día para este recurso (ya recortados por dayMaxEvents). */
+    readonly events: EventDef[];
+    /** Eventos ocultos por el límite (cuentan para "+N more"). */
+    readonly hiddenEvents: EventDef[];
+    readonly moreCount: number;
+}
+
+declare interface ResourceDayGridMonthModel {
+    readonly weeks: ResourceDayGridMonthWeek[];
+    /** Columnas de día visibles por semana (7 menos los días ocultos). */
+    readonly columnCount: number;
+}
+
+declare interface ResourceDayGridMonthWeek {
+    readonly days: ResourceDayGridMonthCell[];
+}
+
+/** Recurso normalizado del dominio. */
+declare interface ResourceDef {
+    readonly id: string;
+    readonly title: string;
+    readonly parentId: string | null;
+    readonly eventColor: string | null;
+    readonly extendedProps: Record<string, unknown>;
+}
+
+/** Recurso de entrada (Scheduler). Admite jerarquía por `children` o `parentId`. */
+export declare interface ResourceInput {
+    id: string;
+    title?: string;
+    parentId?: string;
+    children?: ResourceInput[];
+    eventColor?: string;
+    extendedProps?: Record<string, unknown>;
+}
+
+/**
+ * Plugin Resource: vistas de recursos (Scheduler). Premium en FullCalendar;
+ * aquí gratis y MIT. Depende de timeline.
+ */
+export declare const resourcePlugin: PluginDef;
+
+/** Fila de recurso aplanada para render (con profundidad y estado). */
+declare interface ResourceRow {
+    readonly resource: ResourceDef;
+    readonly depth: number;
+    readonly hasChildren: boolean;
+    readonly expanded: boolean;
+}
+
+declare interface ResourceTimeGridColumn {
+    readonly row: ResourceRow;
+    readonly allDayEvents: EventDef[];
+    readonly timedSegs: TimeGridSeg[];
+}
+
+declare interface ResourceTimeGridModel {
+    readonly date: RsvDate;
+    readonly slots: TimeGridSlot[];
+    readonly columns: ResourceTimeGridColumn[];
+    readonly minMinutes: number;
+    readonly maxMinutes: number;
+    /** % desde arriba del indicador de ahora (compartido), o null. */
+    readonly nowTopPct: number | null;
+}
+
+declare interface ResourceTimelineLane {
+    readonly row: ResourceRow;
+    readonly segs: TimelineSeg[];
+    readonly laneCount: number;
+}
+
+declare interface ResourceTimelineModel {
+    readonly slots: TimelineSlot[];
+    readonly lanes: ResourceTimelineLane[];
+    readonly hourly: boolean;
+}
+
+/** Recurrencia RRULE (RFC 5545, subconjunto). */
+declare interface RRuleRecurrence {
+    readonly kind: "rrule";
+    readonly freq: "DAILY" | "WEEKLY" | "MONTHLY" | "YEARLY";
+    readonly interval: number;
+    readonly count: number | null;
+    readonly until: string | null;
+    /** Días (0=domingo…6=sábado) para FREQ=WEEKLY;BYDAY. */
+    readonly byDay: number[] | null;
+    readonly durationMin: number;
+    readonly exdate: string[];
+}
+
+/**
+ * Fecha del dominio. Tipo OPACO: el dominio nunca inspecciona su interior,
+ * solo la pasa de vuelta a los métodos del DatePort. El adaptador es el único
+ * que conoce su representación real (una instancia inmutable de time-guard).
+ */
+declare type RsvDate = {
+    readonly __brand: "RsvDate";
+};
+
+/** Evento tal como lo recibe el anfitrión (equivalente a `EventApi`). */
+export declare interface RsvEventApi {
+    readonly id: string;
+    readonly groupId: string;
+    readonly title: string;
+    readonly start: Date | null;
+    readonly end: Date | null;
+    readonly startStr: string;
+    readonly endStr: string;
+    readonly allDay: boolean;
+    readonly url: string;
+    readonly display: string;
+    readonly backgroundColor: string;
+    readonly borderColor: string;
+    readonly textColor: string;
+    readonly classNames: string[];
+    readonly extendedProps: Record<string, unknown>;
+    /** Definición original del núcleo, por si se necesita la API completa. */
+    readonly def: EventDef;
+}
+
+/** Rango semiabierto [start, end). */
+declare interface RsvRange {
+    readonly start: RsvDate;
+    readonly end: RsvDate;
+}
+
+/** Vista activa (equivalente reducido de `ViewApi`). */
+export declare interface RsvViewApi {
+    readonly type: string;
+    readonly title?: string;
+    readonly currentStart?: Date;
+    readonly currentEnd?: Date;
+    readonly activeStart?: Date;
+    readonly activeEnd?: Date;
+}
+
+export declare interface SelectArg {
+    start: Date;
+    end: Date;
+    startStr: string;
+    endStr: string;
+    view: RsvViewApi;
+}
+
+declare interface Selection_2 {
+    start: RsvDate;
+    end: RsvDate;
+}
+
+/** Recurrencia simple (días de la semana + franja horaria). */
+declare interface SimpleRecurrence {
+    readonly kind: "simple";
+    readonly daysOfWeek: number[];
+    readonly startTimeMin: number;
+    readonly durationMin: number;
+    readonly startRecur: string | null;
+    readonly endRecur: string | null;
+    readonly exdate: string[];
+}
+
+/** Argumento del slot de etiqueta del eje horario (timeGrid). */
+declare interface SlotLabelContentArg {
+    /** Texto ya formateado (p. ej. "09:00"). */
+    text: string;
+    /** Minutos desde medianoche del slot. */
+    minutes: number;
+    /** Si es una marca mayor (etiquetada). */
+    isMajor: boolean;
+    view: ViewArg;
+}
+
+declare type SlotResult = ComponentChildren | string | HostSlotResult;
+
+/**
+ * Algoritmo de columnas para eventos solapados (interval graph coloring).
+ * Puro y testeable. Devuelve, por evento, su columna y el nº total de columnas
+ * de su grupo de solapamiento.
+ */
+declare interface Spanned {
+    startMin: number;
+    endMin: number;
+}
+
+declare interface TimeGridDay {
+    readonly date: RsvDate;
+    readonly isToday: boolean;
+    readonly isWeekend: boolean;
+    readonly allDayEvents: EventDef[];
+    readonly timedSegs: TimeGridSeg[];
+    /** Rango laborable en % [topPct, bottomPct] para sombrear; null si no aplica. */
+    readonly businessPct: {
+        topPct: number;
+        bottomPct: number;
+    } | null;
+}
+
+declare interface TimeGridModel {
+    readonly slots: TimeGridSlot[];
+    readonly days: TimeGridDay[];
+    readonly minMinutes: number;
+    readonly maxMinutes: number;
+    readonly slotDurationMin: number;
+    readonly nowIndicator: NowIndicator | null;
+}
+
+/**
+ * Plugin TimeGrid: vistas con eje temporal vertical. Solo declara las specs;
+ * el render vive en @reservi/preact.
+ */
+export declare const timeGridPlugin: PluginDef;
+
+declare interface TimeGridSeg extends Spanned {
+    readonly event: EventDef;
+    /** % desde arriba (0–100) dentro del área de tiempo. */
+    readonly topPct: number;
+    readonly heightPct: number;
+    readonly col: number;
+    readonly colCount: number;
+}
+
+declare interface TimeGridSlot {
+    /** Minutos desde slotMinTime. */
+    readonly offsetMin: number;
+    readonly label: string;
+    /** Slot mayor (coincide con slotLabelInterval): lleva etiqueta. */
+    readonly isMajor: boolean;
+}
+
+declare interface TimelineModel {
+    readonly slots: TimelineSlot[];
+    readonly segs: TimelineSeg[];
+    readonly laneCount: number;
+    readonly hourly: boolean;
+}
+
+/** Plugin Timeline: eje temporal horizontal (premium en FullCalendar; aquí gratis). */
+export declare const timelinePlugin: PluginDef;
+
+declare interface TimelineSeg {
+    readonly event: EventDef;
+    readonly leftPct: number;
+    readonly widthPct: number;
+    /** Carril (fila) para evitar solape horizontal. */
+    readonly lane: number;
+    readonly laneCount: number;
+}
+
+declare interface TimelineSlot {
+    readonly leftPct: number;
+    readonly label: string;
+    readonly isMajor: boolean;
+}
+
+/** Secciones de la toolbar (tokens separados por espacios). */
+declare interface ToolbarOptions {
+    start?: string;
+    center?: string;
+    end?: string;
+}
+
+/** Vista activa tal como la reciben los slots y los hooks `*DidMount`. */
+declare interface ViewArg {
+    readonly type: string;
+}
+
+/** Familia de vista (cómo se renderiza). */
+declare type ViewKind = "dayGrid" | "timeGrid" | "list" | "multiMonth" | "timeline" | "resource" | "resourceTimeGrid" | "resourceDayGrid" | "resourceDayGridMonth";
+
+/** Modelo de la vista actual que consume la capa de UI. */
+declare interface ViewModel {
+    readonly type: string;
+    readonly spec: ViewSpec;
+    readonly range: DateRange;
+    readonly title: string;
+    /** Presente solo para vistas dayGrid. */
+    readonly dayGrid?: DayGridModel;
+    /** Presente solo para vistas timeGrid. */
+    readonly timeGrid?: TimeGridModel;
+    /** Presente solo para vistas list. */
+    readonly list?: ListModel;
+    /** Presente solo para vistas multiMonth. */
+    readonly multiMonth?: MultiMonthModel;
+    /** Presente solo para vistas timeline. */
+    readonly timeline?: TimelineModel;
+    /** Presente solo para vistas resource (resource-timeline). */
+    readonly resourceTimeline?: ResourceTimelineModel;
+    /** Presente solo para vistas resourceTimeGrid (recursos como columnas). */
+    readonly resourceTimeGrid?: ResourceTimeGridModel;
+    /** Presente solo para vistas resourceDayGrid. */
+    readonly resourceDayGrid?: ResourceDayGridModel;
+    /** Presente solo para vistas resourceDayGridMonth. */
+    readonly resourceDayGridMonth?: ResourceDayGridMonthModel;
+}
+
+/** Definición declarativa de una vista (la aporta un plugin). */
+declare interface ViewSpec {
+    /** Nombre único, p. ej. "dayGridMonth". */
+    readonly type: string;
+    /** Familia de render. */
+    readonly kind: ViewKind;
+    /** Duración del rango que abarca la vista. */
+    readonly duration: Duration;
+    /** Días ocultos por defecto en esta vista (0=domingo…6=sábado). */
+    readonly hiddenDays?: number[];
+}
+
+export { }