@prolibu-suite/cobalt-core 0.2.0 → 0.4.0

package/dist/types/components/co-data-table/co-data-table.d.ts

@@ -29,6 +29,16 @@ export declare class CoDataTable {
     emptyMessage: string;
     /** Empty state icon (Phosphor icon name). */
     emptyIcon: string;
+    /** Empty-state action button, rendered BY the component (not via slot). Prefer
+     *  this over the `empty-action` slot: a non-shadow component relocates slotted
+     *  light-DOM nodes, so projecting togglable framework content (e.g. a Vue
+     *  `v-if` button) corrupts that framework's virtual DOM. Leave empty to fall
+     *  back to the `empty-action` slot. */
+    emptyActionLabel?: string;
+    /** Variant for the prop-driven empty-action button. */
+    emptyActionVariant: 'primary' | 'secondary' | 'stroke' | 'ghost' | 'danger' | 'success';
+    /** Optional left icon (Phosphor name) for the prop-driven empty-action button. */
+    emptyActionIcon?: string;
     /** Current sort field */
     sortField: string;
     /** Current sort direction */
@@ -42,7 +52,7 @@ export declare class CoDataTable {
     /** Emitted when a column sort is requested */
     coSort: EventEmitter<{
         field: string;
-        order: 'asc' | 'desc';
+        order: 'asc' | 'desc' | '';
     }>;
     /** Emitted when a row is selected/deselected */
     coRowSelect: EventEmitter<{
@@ -72,6 +82,8 @@ export declare class CoDataTable {
         row: any;
         index: number;
     }>;
+    /** Fired when the prop-driven empty-action button (`emptyActionLabel`) is clicked. */
+    coEmptyAction: EventEmitter<void>;
     parsedColumns: CoDataTableColumn[];
     parsedRows: any[];
     parsedSelectedKeys: Set<string>;
@@ -98,8 +110,9 @@ export declare class CoDataTable {
     private getColumnWidth;
     private getTableWidth;
     private renderColgroup;
+    private renderSortIcon;
     private renderHeader;
-    private renderBody;
+    private renderSkeletonBody;
     private renderEmpty;
     render(): any;
 }

package/dist/types/components/co-drawer/co-drawer.d.ts

@@ -25,6 +25,12 @@ export declare class CoDrawer {
     closeOnOverlay: boolean;
     /** Close when pressing Escape */
     closeOnEscape: boolean;
+    /** Render without the modal overlay: no scrim, no body-scroll lock — the
+     *  page behind stays fully interactive. The panel promotes itself to the
+     *  browser top layer (Popover API) so ancestor filters/transforms can't
+     *  clip it. Close vectors: X button, Escape, or the consumer flipping
+     *  `open` — there is deliberately no click-outside in this mode. */
+    modeless: boolean;
     /** Show a loading overlay over the body */
     loading: boolean;
     /** Requested to close (X, backdrop, Esc). Consumer should set `open=false`. */
@@ -41,5 +47,11 @@ export declare class CoDrawer {
     private handleCloseClick;
     private stopPropagation;
     private handleTransitionEnd;
+    private asideEl?;
+    /** Modeless only: keep the aside promoted to the top layer for its whole
+     *  lifetime (mirrors co-overlay's syncPopover; eviction on disconnect is
+     *  automatic). */
+    private promoteModeless;
+    componentDidLoad(): void;
     render(): any;
 }

package/dist/types/components/co-drive-card/co-drive-card.d.ts

@@ -0,0 +1,52 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * co-drive-card — a selectable Drive item card.
+ *
+ * A plain flex/grid surface that `co-card` cannot host: `co-card` projects its
+ * children into a shadow-DOM body that forces block flow, clips with
+ * `overflow:hidden`, locks a 16px radius + a real 1px border, and paints an
+ * opaque surface that occludes the selected accent tint. This component renders
+ * two faithful layouts instead — a `folder` flex row and a `file` column with a
+ * thumbnail — with an absolute corner select-chip, a 1.5px inset selection ring,
+ * and a shadow-sm + hairline hover.
+ *
+ * @slot thumb    - (file) The thumbnail region at the top of the card.
+ * @slot type     - (file) The file-type tile in the foot row. Falls back to
+ *                  <co-file-type-tile> when `ext` is set.
+ * @slot trailing - (folder) Trailing content after the star (e.g. a dots menu).
+ * @slot actions  - (file) The fading action affordance in the foot row.
+ */
+export declare class CoDriveCard {
+    /** Which layout to render. */
+    variant: 'folder' | 'file';
+    /** Vertical rhythm / sizing. */
+    density: 'comfy' | 'compact';
+    /** Accent CSS color driving the icon tile, selection ring and select chip. */
+    accent: string;
+    /** Primary label (name). */
+    name: string;
+    /** Muted secondary line (meta). */
+    meta: string;
+    /** Whether the item is selected. Controlled — parent updates it on coToggleSelect. */
+    selected: boolean;
+    /** Whether the item is starred. */
+    starred: boolean;
+    /** (file) Whether the item is the active/current item — draws a heavier inset ring. */
+    active: boolean;
+    /** (file) File extension used to render a default <co-file-type-tile> in the foot when the `type` slot is empty. */
+    ext?: string;
+    /** Fired when the card is activated (click / Enter / Space). */
+    coOpen: EventEmitter<void>;
+    /** Fired when the select chip is toggled — emits the NEW selected state. */
+    coToggleSelect: EventEmitter<boolean>;
+    /** Fired when the star affordance is clicked. */
+    coStar: EventEmitter<void>;
+    private handleOpen;
+    private handleKeyDown;
+    private handleToggleSelect;
+    private handleStar;
+    private renderSelectChip;
+    private renderFolder;
+    private renderFile;
+    render(): any;
+}

package/dist/types/components/co-drop-zone/co-drop-zone.d.ts

@@ -0,0 +1,38 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * co-drop-zone — a drag-to-upload overlay.
+ *
+ * Wraps arbitrary slotted content and paints an absolute dashed overlay on top
+ * of it while a drag is in progress. Can be driven two ways:
+ *  1. Controlled — the consumer toggles `active` (e.g. from its own drag state).
+ *  2. Self-managed — the host listens for native dragenter/over/leave/drop and
+ *     flips `active` itself, emitting `coDragStateChange` and `coDrop`.
+ *
+ * Report ref: 3.17 (446–449); drag overlay spec: report lines 135–136.
+ */
+export declare class CoDropZone {
+    /** Whether the drag-to-upload overlay is visible. */
+    active: boolean;
+    /** Accent color for the dashed border, badge icon and tinted background. */
+    accent: string;
+    /** Overlay label text. */
+    label: string;
+    /** Phosphor icon name shown in the badge. */
+    icon: string;
+    /** Emitted with the dropped files. */
+    coDrop: EventEmitter<File[]>;
+    /** Emitted whenever the internal drag-over state flips. */
+    coDragStateChange: EventEmitter<boolean>;
+    /**
+     * Nested dragenter/dragleave counter. Without it, moving the cursor over a
+     * slotted child fires `dragleave` (from the parent) then `dragenter` (from the
+     * child), which would flicker the overlay off and on.
+     */
+    private dragDepth;
+    private setActive;
+    private handleDragEnter;
+    private handleDragOver;
+    private handleDragLeave;
+    private handleDrop;
+    render(): any;
+}

package/dist/types/components/co-empty-state/co-empty-state.d.ts

@@ -9,5 +9,11 @@ export declare class CoEmptyState {
     heading?: string;
     /** Descriptive text */
     description?: string;
+    /** Visual style: `plain` (default, current behavior) or `card` (framed white card). */
+    variant: 'plain' | 'card';
+    /** Size scale. `l` grows the medallion (98px) and heading (24/500). */
+    size: 'm' | 'l';
+    /** Phosphor icon weight. Defaults to `light` (plain) / `regular` (card) when unset. */
+    iconWeight?: 'thin' | 'light' | 'regular' | 'bold' | 'fill' | 'duotone';
     render(): any;
 }

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

@@ -0,0 +1,110 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type CoCalendarEvent, type NormalizedEvent } from '@prolibu-suite/cobalt-calendar-utils';
+/**
+ * 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
+ * calendar emits requests (`coEventDrop`, `coDateSelect`) and the host applies
+ * them by updating the `events` prop — leaving it unchanged on failure is the
+ * revert.
+ *
+ * Instants are ISO-8601 strings WITH offset/Z (timed) or "YYYY-MM-DD" (all-day);
+ * the calendar never exposes Date objects. `timeZone` controls wall-clock render.
+ *
+ * @part toolbar - The header toolbar
+ * @part body - The active view container
+ */
+export declare class CoEventCalendar {
+    /** Active view. Phase 1 ships `month`; week/day/agenda land in later phases. */
+    view: 'month' | 'week' | 'day' | 'agenda';
+    /** Anchor date "YYYY-MM-DD" controlling the visible period. Persisted by host. */
+    date?: string;
+    /** Events: an array or a JSON string (raw-HTML use). */
+    events: CoCalendarEvent[] | string;
+    /** BCP-47 locale for labels. */
+    locale: string;
+    /** IANA timezone for wall-clock rendering. Defaults to the browser zone. */
+    timeZone?: string;
+    /** Master interaction gate (per-event `editable` can still lock individuals). */
+    editable: boolean;
+    /** Allow empty-day selection to request a create. */
+    selectable: boolean;
+    /** Max event lanes per day before "+N more". */
+    dayMaxEvents: number;
+    /** Earliest interactable day "YYYY-MM-DD" (past-block). */
+    minDate?: string;
+    /** Latest interactable day "YYYY-MM-DD". */
+    maxDate?: string;
+    /** First day of week, 0=Sun..6=Sat. */
+    firstDayOfWeek: number;
+    /** 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;
+    /** Default minutes for a timed event missing an end. */
+    defaultDurationMinutes: number;
+    /** Internal anchor (YYYY-MM-DD) — mirrors `date`, defaults to today. */
+    anchor: string;
+    /** An event chip was activated. */
+    coEventClick: EventEmitter<{
+        event: NormalizedEvent;
+    }>;
+    /** A date/range was selected (create request). */
+    coDateSelect: EventEmitter<{
+        start: string;
+        end: string;
+        allDay: boolean;
+    }>;
+    /** An event was dragged to a new time (move). `revert` is a host convenience. */
+    coEventDrop: EventEmitter<{
+        event: NormalizedEvent;
+        start: string;
+        end: string;
+        oldStart: string;
+        oldEnd: string;
+        allDay: boolean;
+        revert: () => void;
+    }>;
+    /** The visible period changed → host should refetch and persist the view pref. */
+    coDatesSet: EventEmitter<{
+        view: string;
+        start: string;
+        end: string;
+        activeDate: string;
+    }>;
+    /** The active view changed. */
+    coViewChange: EventEmitter<{
+        view: string;
+    }>;
+    /** "+N more" was activated for a day. */
+    coMoreClick: EventEmitter<{
+        date: string;
+        events: NormalizedEvent[];
+    }>;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    onDateChange(value?: string): void;
+    private get tz();
+    private get normalized();
+    private get viewsList();
+    /** Visible [start, end) of the current month view, as date strings. */
+    private visibleRange;
+    private emitDatesSet;
+    private setAnchor;
+    private goToday;
+    private goPrev;
+    private goNext;
+    private step;
+    private switchView;
+    private handleDaySelect;
+    private handleEventClick;
+    private handleEventDrop;
+    private handleMoreClick;
+    private title;
+    render(): any;
+}

package/dist/types/components/co-file-type-tile/co-file-type-tile.d.ts

@@ -0,0 +1,11 @@
+export declare class CoFileTypeTile {
+    /** File extension (e.g. "pdf", "docx", "png"). Case-insensitive; a leading dot is ignored. */
+    ext: string;
+    /** Tile edge length in px (React uses 44 / 34 / 26). */
+    size: number;
+    /** Corner radius in px (React uses 11 / 9 / 7). */
+    radius: number;
+    /** When true, use the type's tint/accent colors; when false, neutral gray-100 / gray-600. */
+    colorTags: boolean;
+    render(): any;
+}

package/dist/types/components/co-icon/co-icon.d.ts

@@ -1,4 +1,4 @@
-export type IconWeight = 'regular' | 'thin' | 'light' | 'bold' | 'fill' | 'duotone';
+import { type IconWeight } from './iconLoader';
 /**
  * co-icon — Phosphor icon renderer.
  *

package/dist/types/components/co-icon/iconLoader.d.ts

@@ -0,0 +1,6 @@
+export type IconWeight = 'regular' | 'thin' | 'light' | 'bold' | 'fill' | 'duotone';
+/**
+ * Devuelve (y cachea) la PROMESA del SVG para `(weight, name)`. Las llamadas
+ * concurrentes para el mismo icono comparten un único fetch.
+ */
+export declare function loadSvg(name: string, weight: IconWeight): Promise<string>;

package/dist/types/components/co-icon-button/co-icon-button.d.ts

@@ -1,9 +1,15 @@
 export declare class CoIconButton {
     /**
-     * filled = dark background (negro), outlined = light background (blanco + border)
+     * filled = dark background (negro), outlined = light background (blanco + border),
+     * ghost = transparent background, no border, tinted hover (negro-8 on light / blanco-16 on dark).
      * Matches Figma: Secundario → filled, Primario → outlined
      */
     variant: 'filled' | 'outlined' | 'ghost';
+    /**
+     * Surface the button sits on. `dark` → white icon + blanco-16 hover (on-dark theming).
+     * Defaults to `light` (no extra class → identical to previous behavior).
+     */
+    surface: 'light' | 'dark';
     /** Shape: pill or straight corners */
     shape: 'rounded' | 'square';
     /**
@@ -11,6 +17,17 @@ export declare class CoIconButton {
      * xl=80, lg=64, md=56, sm=48, xs=32, xxs=24
      */
     size: 'xl' | 'lg' | 'md' | 'sm' | 'xs' | 'xxs';
+    /**
+     * Override the container box in px (width === height). When set, takes precedence
+     * over the `size` class dimensions — lets you hit 32/36/40 rounded squares.
+     * When omitted, the `size` class dimensions apply (unchanged behavior).
+     */
+    boxSize?: number;
+    /**
+     * Override the rendered icon size in px. When set, takes precedence over the
+     * per-`size` icon default (which is otherwise unchanged — e.g. 16px at xs).
+     */
+    iconSize?: number;
     /** Disabled state */
     disabled: boolean;
     /** Accessible label */

package/dist/types/components/co-input/co-input.d.ts

@@ -42,8 +42,16 @@ export declare class CoInput {
     autocomplete?: string;
     /** Validation status */
     status: 'default' | 'error' | 'success' | 'warning' | 'info';
-    /** Size variant: s (28px), sm (32px), md (40px, default), lg (48px) */
+    /** Size variant: s (28px), sm (32px), md (40px, default), lg (48px).
+     *  In the filled search-pill variant (`fill`) this drives the pill height
+     *  instead (s ≈ 38px). */
     size: 's' | 'sm' | 'md' | 'lg';
+    /** Filled search-pill variant. When true the field renders as a minimal gray
+     *  pill (background gray-100, no border/box-shadow, 10px radius) with a search
+     *  glyph on the left and a plain-`x` clear — the floating label, helper text and
+     *  status chrome are suppressed. When false (default) the field renders
+     *  IDENTICALLY to the standard text field. */
+    fill: boolean;
     /** Label for the integrated action button (Botón variant) */
     actionLabel?: string;
     /** Phosphor icon name for the integrated action button */
@@ -74,5 +82,9 @@ export declare class CoInput {
     private get hasValue();
     private get statusFieldIcon();
     private get helperIcon();
+    /** Filled search-pill variant (fill=true). Minimal chrome: icon-left + native
+     *  input + plain-x clear. No labels, helper text, status icons, chips or action.
+     *  The default field render path is left untouched. */
+    private renderFill;
     render(): any;
 }

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

@@ -37,6 +37,9 @@ export declare class CoJsonField {
     invalidMessage: string;
     /** Label layout: vertical (label above) or horizontal (label beside) */
     layout: 'vertical' | 'horizontal';
+    /** Field size (mirrors co-input paddings; mono font scales 12/13/13/14).
+     *  Vertical extent still comes from `rows`. */
+    size: 's' | 'sm' | 'md' | 'lg';
     /** Emitted on every keystroke with the raw text. */
     coInput: EventEmitter<string>;
     /** Emitted with the committed text on blur. */

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

@@ -0,0 +1,26 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+/**
+ * Action footer for dropdown / list panels (co-popover, co-combobox, …).
+ * Renders one or two full-width action buttons in the standard footer design,
+ * separated from the content above by top padding. Use the props for the common
+ * primary/secondary actions, or the default slot for fully custom content.
+ *
+ * @slot - Custom footer content (rendered after the prop buttons).
+ */
+export declare class CoListFooter {
+    /** Primary (filled) action label. Omit to hide the primary button. */
+    primaryLabel?: string;
+    /** Primary action leading icon (Phosphor). Set to '' to hide the icon. */
+    primaryIcon: string;
+    /** Secondary (outlined) action label. Omit to hide the secondary button. */
+    secondaryLabel?: string;
+    /** Secondary action leading icon (Phosphor). Set to '' to hide the icon. */
+    secondaryIcon: string;
+    /** Emitted when the primary action is clicked. */
+    coPrimary: EventEmitter<void>;
+    /** Emitted when the secondary action is clicked. */
+    coSecondary: EventEmitter<void>;
+    private handlePrimary;
+    private handleSecondary;
+    render(): any;
+}

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

@@ -21,6 +21,17 @@ export declare class CoListItem {
     dense: boolean;
     /** Emitted when item is clicked */
     coSelect: EventEmitter<void>;
+    el: HTMLElement;
+    /** Whether the label / description is currently ellipsis-truncated (drives the tooltip). */
+    private labelTruncated;
+    private descTruncated;
+    private labelEl?;
+    private descEl?;
+    private ro?;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    onTextChange(): void;
+    private measureTruncation;
     private handleClick;
     private handleKeyDown;
     render(): any;

package/dist/types/components/co-media-thumb/co-media-thumb.d.ts

@@ -0,0 +1,21 @@
+/**
+ * An image / video preview region. Renders a cover image when `src` is set,
+ * an optional dark scrim + play button when `video` is true, and a default
+ * slot fallback (for a type-icon box) when there is no `src`.
+ *
+ * @slot - Fallback content shown when `src` is not set (e.g. a type-icon box).
+ */
+export declare class CoMediaThumb {
+    /** Image source URL. When set, a cover image is rendered. */
+    src?: string;
+    /** Show the video overlay (dark scrim + centered play button). */
+    video: boolean;
+    /** Height of the region. Accepts a CSS length or a bare number (→ px). */
+    height: string | number;
+    /** Corner radius in px. */
+    radius: number;
+    /** Alternative text for the image. */
+    alt?: string;
+    private toCss;
+    render(): any;
+}

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

@@ -34,6 +34,10 @@ export declare class CoMenu {
     autoClose: boolean;
     /** Whether the menu panel is visible. Reflected to attribute. */
     open: boolean;
+    /** Fixes the panel to an exact width (e.g. `'210px'`). When unset, the panel
+     *  keeps its intrinsic auto width (min-width 200px). Also tune padding with the
+     *  `--co-menu-padding` CSS var (default 4px; design uses 6px). */
+    width?: string;
     coOpen: EventEmitter<void>;
     coClose: EventEmitter<void>;
     el: HTMLElement;

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

@@ -14,12 +14,21 @@ import { EventEmitter } from '../../stencil-public-runtime';
  * Submenu nesting is unbounded — submenu items can themselves have submenus.
  */
 export declare class CoMenuItem {
-    /** Icon name (Phosphor) rendered before the label. */
+    /** Icon name (Phosphor) rendered before the label. Optional — rows may be
+     *  label-only. */
     icon?: string;
+    /** Overrides the leading icon size (px). Defaults to 16. */
+    iconSize?: number;
     /** Text shown in the row. */
     label?: string;
     /** Tighter row metrics (32px instead of 36px). */
     dense: boolean;
+    /** Marks the row as selected — paints an at-rest gray-100 background. Used by
+     *  single-select menus (sort/type). */
+    selected: boolean;
+    /** Renders a trailing check (size 15) after the label. Pair with `selected`
+     *  to mark the chosen option in a single-select menu. */
+    trailingCheck: boolean;
     /** Visually disabled — pointer events ignored, opacity reduced. */
     disabled: boolean;
     /** `danger` shifts text + icon to the destructive color. Use for Delete, etc. */

package/dist/types/components/co-modal/co-modal.d.ts

@@ -14,14 +14,38 @@ export declare class CoModal {
     closable: boolean;
     /** Close when clicking the overlay backdrop */
     closeOnOverlay: boolean;
-    /** Modal width: sm (400px), md (540px), lg (680px) */
-    size: 'sm' | 'md' | 'lg';
+    /**
+     * Opt-in: close when Escape is pressed. Default false → existing consumers
+     * are unchanged.
+     *
+     * Handled here rather than by forwarding co-overlay's own `closeOnEscape`:
+     * co-overlay emits the SAME `coClose` for a backdrop click and for Escape,
+     * and this component gates that event on `closeOnOverlay`. Forwarding would
+     * therefore swallow Escape whenever `closeOnOverlay` is false.
+     */
+    closeOnEscape: boolean;
+    /**
+     * Modal width: sm (400px), md (540px), lg (680px),
+     * full (min(1400px, 95vw) × 92vh — media/document viewers).
+     *
+     * `full` also drops the body padding and lets the body grow, so a slotted
+     * <video>/<iframe> fills the panel edge-to-edge instead of sitting in a
+     * content-height box.
+     */
+    size: 'sm' | 'md' | 'lg' | 'full';
     /** Hide body section and all border dividers (compact confirm dialogs) */
     noDividers: boolean;
     /** Emitted when the modal requests to close */
     coClose: EventEmitter<void>;
+    /** Close animation finished. */
+    coAfterClose: EventEmitter<void>;
+    /** Open animation finished. */
+    coAfterOpen: EventEmitter<void>;
+    private modalEl?;
     private handleOverlayClick;
     private handleCloseClick;
     private stopPropagation;
+    handleKeydown(e: KeyboardEvent): void;
+    private handleTransitionEnd;
     render(): any;
 }

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

@@ -17,6 +17,13 @@ export declare class CoNumberField {
     size: 's' | 'sm' | 'md' | 'lg';
     /** Show clear button when the field has a value */
     clearable: boolean;
+    /**
+     * Display format. With 'rate' | 'percent' the `value` stays a DECIMAL
+     * (e.g. 0.15) but the field shows/edits the PERCENT (15) with a "%" suffix.
+     * value/min/max/step are always in the underlying (decimal) unit.
+     * Reflected so it survives lazy hydration when set via the Vue wrapper.
+     */
+    format?: 'rate' | 'percent';
     focused: boolean;
     el: HTMLElement;
     coChange: EventEmitter<number | null>;
@@ -31,6 +38,12 @@ export declare class CoNumberField {
     private get canDecrement();
     private get canIncrement();
     private clamp;
+    /** Whether the value↔display conversion (×100) is active. */
+    private get scaled();
+    /** Stored decimal → shown number (0.15 → 15). toFixed avoids FP artifacts. */
+    private toDisplay;
+    /** Typed number → stored decimal (15 → 0.15). */
+    private fromDisplay;
     private emitValue;
     private handleDecrement;
     private handleIncrement;

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

@@ -0,0 +1,101 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { OptionListItem } from './optionListLogic';
+/**
+ * Núcleo de lista de opciones — la única fuente del look & behavior de los
+ * dropdowns Cobalt (co-ref-field, co-combobox, co-autocomplete,
+ * co-command-search) y de los pickers de celda de suite-v2.
+ *
+ * NO renderiza trigger ni chrome de panel (popover/dialog/ancho): eso es del
+ * host. Es 100% controlada: no muta `value`; emite y el host decide.
+ *
+ * @slot footer - Footer del panel (normalmente <co-list-footer>).
+ */
+export declare class CoOptionList {
+    el: HTMLElement;
+    /** JSON string o array de OptionListItem. */
+    items: string | OptionListItem[];
+    /** Selección actual: id single o JSON array de ids. */
+    value: string;
+    /** Display-items de la selección (para selected-first con ids fuera de página). */
+    selectedItems: string | OptionListItem[];
+    multiple: boolean;
+    /** Partición selected-first (snapshot al llamar snapshotOrder()). */
+    selectedFirst: boolean;
+    /** Afford. del seleccionado: check (combobox/autocomplete) o X deselect (ref-field). */
+    selectedAffordance: 'check' | 'deselect';
+    /** Botón remove por fila seleccionada en multiple (tags de combobox). */
+    removableItems: boolean;
+    searchable: boolean;
+    searchPlaceholder: string;
+    searchDebounce: number;
+    /** Pre-seed del término (modo convert de las celdas). */
+    initialTerm: string;
+    loading: boolean;
+    /** Total del server: deriva hasMore + hint "N more results". */
+    total: number;
+    /** Fallback cuando el host no conoce totales (⌘K). total>0 manda. */
+    hasMore: boolean;
+    emptyMessage: string;
+    /** Si se setea y hay selección, fila "quitar selección" al tope. */
+    clearOptionLabel: string;
+    /** Lista virtualizada (autocomplete/combobox). Ignora `group`. */
+    virtual: boolean;
+    /** Resalta el match del término en los labels. */
+    highlightMatches: boolean;
+    /** Término externo para highlight (input en el host, p.ej. ⌘K). */
+    highlightTerm: string;
+    avatarShape: 'circle' | 'square';
+    coSearch: EventEmitter<string>;
+    coChange: EventEmitter<{
+        value: string | string[];
+        item: OptionListItem;
+    }>;
+    coLoadMore: EventEmitter<void>;
+    coClearSelection: EventEmitter<void>;
+    coRemoveItem: EventEmitter<string>;
+    term: string;
+    activeIndex: number;
+    scrollTop: number;
+    private searchInputEl?;
+    private optionsEl?;
+    private osInstance?;
+    private debounceTimer?;
+    /** Snapshot selected-first (ver snapshotOrder). */
+    private sortSnapshot;
+    private displaySnapshot;
+    private get parsedItems();
+    private get selectedIds();
+    private get orderedItems();
+    private get effectiveHighlightTerm();
+    componentWillLoad(): void;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    onItemsChange(): void;
+    /** Re-toma el snapshot selected-first. El host la llama al abrir su panel. */
+    snapshotOrder(): Promise<void>;
+    /**
+     * Enfoca el input de búsqueda esperando visibilidad real: el panel del host
+     * se vuelve visible frames después (showPopover/position en rAF) y focus()
+     * sobre subtree oculto es no-op silencioso. Reintenta ~20 frames.
+     */
+    focusSearch(): Promise<void>;
+    /** Navegación para hosts con input externo. true = tecla consumida (host hace preventDefault). */
+    handleKey(e: KeyboardEvent): Promise<boolean>;
+    private takeSnapshot;
+    private processKey;
+    /**
+     * Enter sobre un control real (footer, fila clear) activa ese control
+     * nativamente — nunca el highlight (regla heredada de CellRefPicker).
+     */
+    private onRootKeyDown;
+    private onSearchInput;
+    private pick;
+    private maybeLoadMore;
+    private onNativeScroll;
+    private scrollActiveIntoView;
+    private renderLeading;
+    private renderLabelText;
+    private renderRow;
+    private renderVirtual;
+    render(): any;
+}