@prolibu-suite/cobalt-core 0.7.0 → 0.8.0

package/dist/types/components/co-calendar-timegrid/co-calendar-timegrid.d.ts

@@ -0,0 +1,178 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type NormalizedEvent } from '@prolibu-suite/cobalt-calendar-utils';
+/**
+ * co-calendar-timegrid — the Week/Day time-grid. The shell renders it with
+ * `dates` = 7 day-keys (week) or 1 (day). Presentation + interaction only; the
+ * host owns data (CONTROLLED). All instant math is delegated to the engine — the
+ * only timezone boundary is the `timeZone` prop (wall-clock render).
+ */
+export declare class CoCalendarTimegrid {
+    el: HTMLElement;
+    events: NormalizedEvent[];
+    /** Visible day keys "YYYY-MM-DD" (7 = week, 1 = day). */
+    dates: string[];
+    locale: string;
+    timeZone: string;
+    editable: boolean;
+    selectable: boolean;
+    minDate?: string;
+    maxDate?: string;
+    slotMinutes: number;
+    snapMinutes: number;
+    defaultDurationMinutes: number;
+    scrollTime: string;
+    nowIndicator: boolean;
+    /** Cargando: en vez de los eventos pinta bloques skeleton en las columnas.
+     *  La grilla (eje de horas, líneas, cabecera de días, franja de todo-el-día)
+     *  se mantiene: lo único que todavía no se sabe son los eventos. */
+    loading: boolean;
+    allDaySlot: boolean;
+    minTime: string;
+    maxTime: string;
+    /** Minute of "now" for the indicator; refreshed on a 60s timer. */
+    nowMinutes: number;
+    nowDay: string;
+    /** Roving-tabindex focus position for keyboard navigation over slots. */
+    focusDate: string;
+    focusMin: number;
+    /** A time range was selected on an empty area (create request). */
+    coRangeSelect: EventEmitter<{
+        start: string;
+        end: string;
+        /** Viewport-anchored rect of the selected area, for the host to anchor a quick-create bubble. */
+        rect?: {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+        };
+    }>;
+    coEventClick: EventEmitter<{
+        id: string;
+        rect?: DOMRect;
+    }>;
+    coEventDrop: EventEmitter<{
+        id: string;
+        start: string;
+        end: string;
+        oldStart: string;
+        oldEnd: string;
+        allDay: boolean;
+    }>;
+    /** Doble activación de un chip (direct-edit request del host). */
+    coEventDblClick: EventEmitter<{
+        id: string;
+        rect?: DOMRect;
+    }>;
+    selDate: string | null;
+    selStartMin: number;
+    selEndMin: number;
+    private selecting;
+    /** Coords crudas del último pointermove: el getBoundingClientRect corre UNA vez
+     * por frame, dentro del rAF (antes corría a ~120Hz, en el move crudo). */
+    private pendingSel;
+    private selRaf;
+    private pendingDrag;
+    private dragRaf;
+    private onWindowPointerUp;
+    dragId: string | null;
+    private dragMode;
+    private dragGrabOffsetMin;
+    private dragDurationMin;
+    private dragDate;
+    private dragStartMin;
+    private dragEndMin;
+    private origStartMin;
+    private origEndMin;
+    private origDate;
+    private suppressNextClick;
+    private dragArmedId;
+    private dragStartPointer;
+    private onWindowPointerMove;
+    private onWindowPointerUpDrag;
+    private nowTimer?;
+    private rootEl?;
+    private scrollEl?;
+    /** Ghost imperativo del drag: se posiciona con style directo, nunca por vdom. */
+    private ghostEl?;
+    /** Rects de las columnas cacheados AL AGARRAR: con esto el frame de drag es
+     * aritmética pura (antes: ~9 getBoundingClientRect + 2 querySelector/frame,
+     * que además forzaban reflow síncrono al escribir estilos en el mismo rAF). */
+    private colRects;
+    private gridRect;
+    private onDragViewportChange;
+    /** Memo de layoutTimeGrid/layoutAllDay/byId por identidad de inputs. */
+    private layoutCache?;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    /** Limpia el resaltado persistente de selección (lo llama el host al cerrar
+     * su bubble/form de creación). */
+    clearSelection(): Promise<void>;
+    /** Un refetch (post-save) invalida la referencia visual de la selección. */
+    onEventsChange(): void;
+    private refreshNow;
+    private get minM();
+    private get maxM();
+    private scrollToInitial;
+    /** Visible day keys, with the same fallback the render uses. */
+    private visibleDates;
+    /** Slot size guarded: ahora alimenta un `calc()` (un 0/NaN dejaría la grilla
+     * sin altura, silenciosamente). */
+    private get slotM();
+    /** Number of slot rows in the visible window (drives the body height). */
+    private slotCount;
+    /** Hour marks inside the visible window — one axis label each (was 1 div per
+     * slot with a label only on the hour). */
+    private hourList;
+    /** Minutes-of-day at a clientY within a column element, snapped and clamped. */
+    private minutesFromPointer;
+    /** Same math as minutesFromPointer but over the cached grid rect (drag path):
+     * cero lecturas de layout por frame. */
+    private minutesFromCachedY;
+    private minutesAtFraction;
+    /** Snapshot de la geometría de columnas al empezar un drag. Se re-toma solo
+     * cuando el viewport cambia (scroll del body / resize), nunca por frame. */
+    private captureDragRects;
+    private bindDragViewportListeners;
+    /** Marca la interacción en el root (hover/hit-testing off en los chips). No es
+     * @State a propósito: no debe disparar un render por drag. */
+    private setInteracting;
+    /** Build an ISO instant (UTC) for a wall-clock minute-of-day on a given day. */
+    private toInstant;
+    private isDayInteractable;
+    private startSelection;
+    private extendSelection;
+    private finishSelection;
+    /** Viewport rect of the selected span, mirroring the `.tg__selection` ghost's
+     * fraction math over the column's own bounding box. Never throws: falls back to
+     * the whole-column rect, or undefined if the column isn't in the DOM. */
+    private selectionRect;
+    private eventById;
+    /** The day column under a clientX (week can drop across days) — resuelto por
+     * aritmética sobre los rects cacheados, sin tocar el DOM. */
+    private dateKeyAtX;
+    private startMove;
+    private startResize;
+    private beginDragInteraction;
+    /** Ghost del drag escrito DIRECTO al DOM: el vdom no participa (los campos del
+     * drag son privados a propósito — promoverlos a @State volvería a re-renderizar
+     * la grilla entera por frame). */
+    private paintGhost;
+    private hideGhost;
+    /** Igual que extendSelection: un solo apply por frame (ver comentario allí). */
+    private trackDrag;
+    private applyDrag;
+    private finishDrag;
+    /** Roving-tabindex keyboard nav: ↑/↓ by slot, ←/→ by day, Enter/Space to select. */
+    private handleKeyDown;
+    private shiftFocusDate;
+    private renderSelectionGhost;
+    private renderEventBox;
+    private renderAllDayBar;
+    /** Los 3 cómputos de layout del render, memoizados por IDENTIDAD de inputs
+     * (`events` llega memoizado del shell): un re-render por drag/now-tick/focus
+     * no vuelve a empaquetar la semana. */
+    private getLayouts;
+    render(): any;
+}

package/dist/types/components/co-date-time-picker/co-date-time-picker.d.ts

@@ -0,0 +1,131 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { Placement } from '../../utils/positioning';
+/**
+ * Date + TIME picker: one field, one popover. Composes `co-popover` (floating
+ * panel, outside-click) + `co-calendar` (day grid) + a scrollable list of times
+ * beside it — the Google Calendar layout.
+ *
+ * VALUE CONTRACT — the committed `value` is a UTC ISO instant
+ * ("2026-07-25T21:30:00.000Z"), never a wall-clock string. The wall clock the
+ * user sees and edits is rendered in `timeZone` (IANA; browser zone when
+ * omitted). All ISO↔wall-clock conversion goes through the calendar engine
+ * (`@prolibu-suite/cobalt-calendar-utils`), so DST comes from the platform tz
+ * database — the same boundary `co-calendar-timegrid` uses. A date-only value
+ * ("2026-07-25") is NOT an instant: it is read as that wall-clock day in
+ * `timeZone` at {@link DEFAULT_MINUTES} (09:00), never as UTC midnight (which
+ * would shift the day west of UTC).
+ *
+ * INTERACTION (Google):
+ *   - Click the field → opens. Picking a DAY commits and keeps the panel open
+ *     (you almost always want to set the hour next); picking a TIME commits and
+ *     closes. So there is no draft/apply step and no confirm button.
+ *   - ArrowDown on the field → moves focus into the calendar grid.
+ *   - The time list is a listbox: Arrow/Home/End/PageUp/PageDown move the active
+ *     option, Enter/Space selects it.
+ *   - Escape → closes and returns focus to the field. Outside click → closes.
+ *
+ * Escape is owned here (co-popover `closeOnEscape=false`) so focus can return to
+ * the field; outside-click stays with co-popover.
+ *
+ * @part field - The bordered trigger row
+ * @part label - The field label
+ * @part display - The button that shows the formatted value
+ * @part clear - The clear button
+ * @part helper - The helper/error text row
+ */
+export declare class CoDateTimePicker {
+    el: HTMLElement;
+    /** Committed value: UTC ISO instant ("2026-07-25T21:30:00.000Z") or null. */
+    value: string | null;
+    /** IANA zone the wall clock is rendered in. Defaults to the browser zone. */
+    timeZone?: string;
+    /** Minutes between consecutive options in the time list. */
+    stepMinutes: number;
+    /** 12-hour clock (Google style). `false` renders a 24h clock. */
+    hour12: boolean;
+    /** Earliest selectable day. Date-only "YYYY-MM-DD" or an instant. */
+    min?: string;
+    /** Latest selectable day. Date-only "YYYY-MM-DD" or an instant. */
+    max?: string;
+    disabledDates?: string[] | string;
+    disabledDaysOfWeek?: number[] | string;
+    locale: string;
+    /** Date part of the trigger text (tokens yyyy/yy/MMMM/MMM/MM/M/dd/d). */
+    displayFormat: string;
+    firstDayOfWeek: number;
+    label?: string;
+    placeholder?: string;
+    /** Field size, mirrors co-input/co-date-field: s 28 / sm 32 / md 40 / lg 48. */
+    size: 's' | 'sm' | 'md' | 'lg';
+    /** `flat` strips the trigger's border/background so it reads as content. */
+    variant: 'default' | 'flat';
+    name?: string;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    clearable: boolean;
+    invalid: boolean;
+    errorMessage?: string;
+    helperText?: string;
+    /** Label layout: vertical (label above) or horizontal (label beside). */
+    layout: 'vertical' | 'horizontal';
+    /** Popover placement relative to the field. */
+    placement: Placement;
+    /** Whether the panel is open. */
+    open: boolean;
+    /** Max viewport width (px) that renders the panel as a bottom sheet. */
+    mobileBreakpoint: number;
+    /** True when the viewport is at/under `mobileBreakpoint`. */
+    isMobile: boolean;
+    /** Minutes-of-day highlighted by the keyboard in the time list. */
+    activeMinutes: number;
+    /** Committed instant (UTC ISO) or null. */
+    coChange: EventEmitter<string | null>;
+    coClear: EventEmitter<void>;
+    coFocus: EventEmitter<void>;
+    coBlur: EventEmitter<void>;
+    coOpen: EventEmitter<void>;
+    coClose: EventEmitter<void>;
+    private popoverEl?;
+    private calendarEl?;
+    private triggerBtn?;
+    private listEl?;
+    private pendingFocusGrid;
+    private pendingFocusTrigger;
+    /** 'center' when the list is (re)opened, 'nearest' while arrowing through it. */
+    private pendingScroll;
+    private mql?;
+    private mqlHandler;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    onOpenChange(next: boolean): void;
+    private get zone();
+    private get isInvalid();
+    /** Wall clock of the committed value in `zone`, or null when empty/invalid. */
+    private get parts();
+    /** Calendar bounds are date-only; accept an instant and reduce it to its day. */
+    private dayBound;
+    private setOpen;
+    /** Write day+minutes as a UTC instant and notify. */
+    private commit;
+    private onTriggerKeyDown;
+    private onClearClick;
+    private onCalendarSelect;
+    private pickTime;
+    private onListKeyDown;
+    private onPopoverOpen;
+    private onPopoverClose;
+    private onRootKeyDown;
+    private focusGridSoon;
+    private scrollActiveIntoView;
+    componentDidRender(): void;
+    private get step();
+    /** Grid of minutes-of-day, plus the committed hour when it falls off-grid
+     *  (an imported 16:37 meeting must stay visible and selectable). */
+    private get options();
+    private renderTrigger;
+    private renderPanel;
+    private renderHelper;
+    private renderLabel;
+    render(): any;
+}

package/dist/types/components/co-event-calendar/co-event-calendar.d.ts

@@ -4,8 +4,8 @@ import { type CoCalendarEvent, type NormalizedEvent } from '@prolibu-suite/cobal
  * co-event-calendar — the public entry point of the Cobalt Calendars family.
  *
  * Owns view state, the visible anchor date, event normalization and the toolbar,
- * and delegates rendering to the active view (Phase 1: month). All hard math
- * lives in `@prolibu-suite/cobalt-calendar-utils`. Events are CONTROLLED: the
+ * and delegates rendering to the active view (month/week/day; agenda pending).
+ * All hard math lives in `@prolibu-suite/cobalt-calendar-utils`. Events are CONTROLLED: the
  * calendar emits requests (`coEventDrop`, `coDateSelect`) and the host applies
  * them by updating the `events` prop — leaving it unchanged on failure is the
  * revert.
@@ -16,8 +16,16 @@ import { type CoCalendarEvent, type NormalizedEvent } from '@prolibu-suite/cobal
  * @part toolbar - The header toolbar
  * @part body - The active view container
  */
+type StatusColorsProp = Record<string, {
+    backgroundColor?: string;
+    borderColor?: string;
+}> | string;
 export declare class CoEventCalendar {
-    /** Active view. Phase 1 ships `month`; week/day/agenda land in later phases. */
+    el: HTMLElement;
+    /** Limpia el resaltado persistente de selección de la vista activa (timegrid
+     * o month) — lo llama el host al cerrar su bubble/form de creación. */
+    clearRangeSelection(): Promise<void>;
+    /** Active view. `month`/`week`/`day` are implemented; `agenda` is pending. */
     view: 'month' | 'week' | 'day' | 'agenda';
     /** Anchor date "YYYY-MM-DD" controlling the visible period. Persisted by host. */
     date?: string;
@@ -42,23 +50,45 @@ export declare class CoEventCalendar {
     /** Views offered in the switcher. Defaults to the implemented set. */
     availableViews: string[] | string;
     /** Optional status→{backgroundColor,borderColor} map (object or JSON string). */
-    statusColors?: Record<string, {
-        backgroundColor?: string;
-        borderColor?: string;
-    }> | string;
+    statusColors?: StatusColorsProp;
     /** Default minutes for a timed event missing an end. */
     defaultDurationMinutes: number;
+    /** Show the all-day lane in week/day views. */
+    allDaySlot: boolean;
+    /** Visible-hours window for week/day (minutes-of-day bounds as "HH:mm"). */
+    minTime: string;
+    maxTime: string;
+    /** Slot/snap granularity (minutes) for week/day. */
+    slotMinutes: number;
+    snapMinutes: number;
+    /** Initial scroll position for week/day ("HH:mm"). */
+    scrollTime: string;
+    /** Show the current-time indicator in week/day. */
+    nowIndicator: boolean;
+    /** Cargando eventos: se propaga a la grilla (mes/timegrid), que reemplaza
+     *  SUS chips por bloques skeleton y conserva toda su estructura — bordes,
+     *  cabecera de días, eje de horas. El toolbar sigue operable y nada se
+     *  desmonta, así no se pierde el scroll de semana/día. */
+    loading: boolean;
     /** Internal anchor (YYYY-MM-DD) — mirrors `date`, defaults to today. */
     anchor: string;
     /** An event chip was activated. */
     coEventClick: EventEmitter<{
         event: NormalizedEvent;
+        rect: DOMRect | null;
     }>;
     /** A date/range was selected (create request). */
     coDateSelect: EventEmitter<{
         start: string;
         end: string;
         allDay: boolean;
+        /** Viewport-anchored rect of the selected day/range, for the host to anchor a quick-create bubble. */
+        rect: DOMRect | {
+            top: number;
+            left: number;
+            width: number;
+            height: number;
+        } | null;
     }>;
     /** An event was dragged to a new time (move). `revert` is a host convenience. */
     coEventDrop: EventEmitter<{
@@ -70,6 +100,11 @@ export declare class CoEventCalendar {
         allDay: boolean;
         revert: () => void;
     }>;
+    /** An event chip was double-activated (direct-edit request). */
+    coEventDblClick: EventEmitter<{
+        event: NormalizedEvent;
+        rect: DOMRect | null;
+    }>;
     /** The visible period changed → host should refetch and persist the view pref. */
     coDatesSet: EventEmitter<{
         view: string;
@@ -90,9 +125,24 @@ export declare class CoEventCalendar {
     componentDidLoad(): void;
     onDateChange(value?: string): void;
     private get tz();
+    /**
+     * Memo for the `normalized` getter below. Re-normalizing on every access is
+     * wasted work (render reads it twice) AND, since `normalizeEvents` always
+     * returns a fresh array, breaks referential-equality memos downstream that
+     * depend on a stable `events` reference (layout/packing caching). Keyed by
+     * the raw prop identities that feed normalization — `events`/`statusColors`
+     * are compared by `===` (stable array/string/object reference from the
+     * host unless it actually changed), `defaultDurationMinutes` by value.
+     */
+    private _normCache?;
     private get normalized();
     private get viewsList();
-    /** Visible [start, end) of the current month view, as date strings. */
+    /** Sunday=0 UTC day-of-week of a date-only key (tz-independent). */
+    private dowOf;
+    private weekStart;
+    /** Day keys the active view renders: 7 for week, 1 for day, [] for month. */
+    private get visibleDates();
+    /** Visible [start, end) of the active view, as date strings. */
     private visibleRange;
     private emitDatesSet;
     private setAnchor;
@@ -102,9 +152,12 @@ export declare class CoEventCalendar {
     private step;
     private switchView;
     private handleDaySelect;
+    private handleRangeSelect;
     private handleEventClick;
+    private handleEventDblClick;
     private handleEventDrop;
     private handleMoreClick;
     private title;
     render(): any;
 }
+export {};

package/dist/types/components/co-event-popover/co-event-popover.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type Placement } from '../../utils/positioning';
+/**
+ * co-event-popover — anchored detail card (Google-Calendar-style) for a calendar
+ * event. Non-modal, dismissible. Anchors to a viewport `anchorRect` (the chip's
+ * getBoundingClientRect), promotes to the top-layer (the calendar shell has
+ * contain:layout ancestors that re-anchor position:fixed), and closes on Escape /
+ * outside-click. Content is slotted by the host (suite-v2 fills the meeting fields).
+ */
+export declare class CoEventPopover {
+    el: HTMLElement;
+    open: boolean;
+    /** Anchor rect in viewport coords (chip.getBoundingClientRect()). */
+    anchorRect?: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    placement: Placement;
+    /** Accent color for the leading dot (event color). */
+    color?: string;
+    /** Render the leading color dot. Set false for dot-less content (quick-create). */
+    dot: boolean;
+    closeOnEscape: boolean;
+    closeOnClickOutside: boolean;
+    /** Accessible name for the panel (role="dialog" needs one). */
+    popoverLabel?: string;
+    coClose: EventEmitter<void>;
+    private panelEl?;
+    private prevFocus?;
+    componentDidLoad(): void;
+    onOpenChange(v: boolean): void;
+    onAnchorChange(): void;
+    disconnectedCallback(): void;
+    private promoteAndPosition;
+    private dismissPanel;
+    private teardownListeners;
+    private position;
+    private onScroll;
+    private onKeydown;
+    private onPointerDown;
+    private requestClose;
+    render(): any;
+}

package/dist/types/components/co-menu-item/co-menu-item.d.ts

@@ -21,6 +21,9 @@ export declare class CoMenuItem {
     iconSize?: number;
     /** Text shown in the row. */
     label?: string;
+    /** Optional second line under the label (muted, smaller) — e.g. what an
+     *  export method means. The row auto-grows (min-height, not height). */
+    caption?: string;
     /** Tighter row metrics (32px instead of 36px). */
     dense: boolean;
     /** Marks the row as selected — paints an at-rest gray-100 background. Used by

package/dist/types/components/co-option-list/co-option-list.d.ts

@@ -25,6 +25,8 @@ export declare class CoOptionList {
     selectedAffordance: 'check' | 'deselect';
     /** Botón remove por fila seleccionada en multiple (tags de combobox). */
     removableItems: boolean;
+    /** Habilita reorder por drag del bloque de seleccionados (selected-first). */
+    reorderable: boolean;
     searchable: boolean;
     searchPlaceholder: string;
     searchDebounce: number;
@@ -57,9 +59,22 @@ export declare class CoOptionList {
     coLoadMore: EventEmitter<void>;
     coClearSelection: EventEmitter<void>;
     coRemoveItem: EventEmitter<string>;
+    /** Emitido tras un drag-reorder: nuevo orden de ids seleccionados + ítem movido. */
+    coReorder: EventEmitter<{
+        value: string[];
+        item: OptionListItem;
+    }>;
     term: string;
     activeIndex: number;
     scrollTop: number;
+    /** Fila armada para drag (handle presionado). */
+    armedKey: string;
+    /** Fila que se está arrastrando. */
+    dragKey: string;
+    /** Fila hover como drop-target. */
+    overKey: string;
+    /** Dirección del drop sobre overKey (true = el ítem cae DESPUÉS del target). */
+    dropAfter: boolean;
     private searchInputEl?;
     private optionsEl?;
     private osInstance?;
@@ -73,6 +88,7 @@ export declare class CoOptionList {
     private get effectiveHighlightTerm();
     componentWillLoad(): void;
     componentDidRender(): void;
+    connectedCallback(): void;
     disconnectedCallback(): void;
     onItemsChange(): void;
     /** Re-toma el snapshot selected-first. El host la llama al abrir su panel. */
@@ -94,6 +110,13 @@ export declare class CoOptionList {
     private onRootKeyDown;
     private onSearchInput;
     private pick;
+    private handleRowDragStart;
+    private handleRowDragOver;
+    private handleRowDrop;
+    private handleRowDragEnd;
+    private handleRowDragLeave;
+    private disarmDrag;
+    private resetDragState;
     private maybeLoadMore;
     private onNativeScroll;
     private scrollActiveIntoView;

package/dist/types/components/co-option-list/optionListLogic.d.ts

@@ -51,6 +51,9 @@ export declare function orderItems(items: OptionListItem[], snapshotIds: Set<str
 /** Aplana a filas de render insertando un header cuando `group` cambia
  *  (groupItems de co-command-search). `index` cuenta solo items. */
 export declare function buildRows(items: OptionListItem[]): OptionListRow[];
+/** Mueve `fromId` a la posición de `toId` en `order`. No muta el input;
+ *  devuelve el mismo array (referencia) si es no-op. */
+export declare function reorderIds(order: string[], fromId: string, toId: string): string[];
 /** Siguiente highlight: wrap, salta disabled. -1 = sin items navegables. */
 export declare function nextActiveIndex(current: number, delta: 1 | -1, items: OptionListItem[]): number;
 /** `total > 0` tiene precedencia (deriva remaining); si no, vale `hasMoreProp`. */

package/dist/types/components/co-provider-logo/co-provider-logo.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Logo de marca de un proveedor externo (Google, Microsoft), a color y
+ * self-contained (SVG inline — nunca una URL remota).
+ *
+ * `plated` lo monta sobre un disco blanco: es lo que hace legible una marca a
+ * color cuando va encima de una superficie teñida (el badge de un evento de
+ * calendario externo, que hereda el color del calendario).
+ */
+export declare class CoProviderLogo {
+    /** Proveedor: `google` | `microsoft`. Uno desconocido no pinta nada. */
+    provider: string;
+    /** Lado del logo en px (los viewBox son cuadrados). */
+    size: number;
+    /** Disco blanco de fondo para contraste sobre superficies de color. */
+    plated: boolean;
+    render(): any;
+}

package/dist/types/components/co-ref-field/co-ref-field.d.ts

@@ -130,6 +130,7 @@ export declare class CoRefField {
     private handlePopoverClose;
     private handleTriggerClick;
     private handleOptionClick;
+    private handleReorder;
     private handleClear;
     private handleRemoveChip;
     private handleFooterPrimary;

package/dist/types/components/co-tab-group/co-tab-group.d.ts

@@ -16,5 +16,10 @@ export declare class CoTabGroup {
         with the default pill variant. */
     private onSlotChange;
     private syncTabs;
+    /** Wheel → horizontal scroll cuando el track desborda (los tabs clipean con
+        `overflow-x`, ver CSS): la rueda vertical del mouse scrollea el strip.
+        Solo consume el evento si realmente puede desplazarse en esa dirección —
+        en los extremos deja pasar el scroll a la página. */
+    private onWheel;
     render(): any;
 }