@erplora/outfitkit 0.1.1

package/dist/components/ok-lightbox/ok-lightbox.d.ts

@@ -0,0 +1,59 @@
+import { LitElement } from 'lit';
+export type OkLightboxItemType = 'img' | 'video';
+export interface OkLightboxItem {
+    /** URL del medio (imagen o vídeo). */
+    src: string;
+    /** Texto alternativo / nombre de fichero mostrado en la cabecera. */
+    alt?: string;
+    /** Tipo de medio; por defecto `img`. */
+    type?: OkLightboxItemType;
+    /** URL opcional para la miniatura del filmstrip (si difiere de `src`). */
+    thumb?: string;
+}
+export interface OkLightboxLabels {
+    /** aria-label del botón anterior. */
+    prev: string;
+    /** aria-label del botón siguiente. */
+    next: string;
+    /** aria-label del botón cerrar. */
+    close: string;
+    /** aria-label del botón descargar. */
+    download: string;
+    /** aria-label del botón pantalla completa. */
+    fullscreen: string;
+}
+export declare class OkLightbox extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Medios a mostrar. */
+    items: OkLightboxItem[];
+    /** Índice activo (0-based). */
+    index: number;
+    /** Muestra/oculta el visor. */
+    open: boolean;
+    /** Textos traducibles (merge sobre los defaults en inglés). */
+    labels: Partial<OkLightboxLabels>;
+    private shown;
+    private get t();
+    private portalRoot;
+    disconnectedCallback(): void;
+    private readonly onKeydown;
+    private bind;
+    private unbind;
+    private ensurePortal;
+    protected updated(changed: Map<string, unknown>): void;
+    private get safeIndex();
+    private prefersReducedMotion;
+    private go;
+    private setIndex;
+    private requestClose;
+    private fileName;
+    render(): unknown;
+    private overlayTemplate;
+    private renderThumb;
+    private toggleFullscreen;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-lightbox': OkLightbox;
+    }
+}

package/dist/components/ok-logo-cloud/ok-logo-cloud.d.ts

@@ -0,0 +1,14 @@
+import { LitElement } from 'lit';
+export declare class OkLogoCloud extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Etiqueta opcional encima de los logos. */
+    label?: string;
+    /** Desplaza la fila en bucle (duplica los logos en el HTML para continuidad). */
+    marquee: boolean;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-logo-cloud': OkLogoCloud;
+    }
+}

package/dist/components/ok-loyalty-card/ok-loyalty-card.d.ts

@@ -0,0 +1,35 @@
+import { LitElement } from 'lit';
+/** Nivel/tier de la tarjeta de fidelización. */
+export type OkLoyaltyTier = 'silver' | 'gold' | 'platinum' | 'brand';
+/** Tamaño de la tarjeta. */
+export type OkLoyaltySize = 'sm' | 'md' | 'lg';
+export declare class OkLoyaltyCard extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Nombre del titular de la tarjeta. */
+    holder?: string;
+    /** Número de socio/tarjeta (se renderiza en mono). */
+    number?: string;
+    /** Puntos de fidelización (string o número, se muestra tal cual). */
+    points?: string;
+    /** Etiqueta bajo el valor de puntos. */
+    pointsLabel: string;
+    /** Nombre de marca/programa en la cabecera. */
+    brand: string;
+    /** Nivel/tier visual. */
+    tier: OkLoyaltyTier;
+    /** Etiqueta del badge de tier (por defecto = el tier capitalizado). */
+    tierLabel?: string;
+    /** Texto previo al valor "miembro desde / caduca". */
+    metaLabel: string;
+    /** Valor de la meta (fecha de alta o caducidad, ej. "03 / 24"). */
+    metaValue?: string;
+    /** Tamaño de la tarjeta. */
+    size: OkLoyaltySize;
+    private get badgeText();
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-loyalty-card': OkLoyaltyCard;
+    }
+}

package/dist/components/ok-mail/ok-mail.d.ts

@@ -0,0 +1,117 @@
+import { LitElement } from 'lit';
+/** Carpeta del buzón (Bandeja, Enviados, Borradores…). */
+export interface OkMailFolder {
+    /** Id estable de la carpeta. */
+    id: string;
+    /** Etiqueta visible. */
+    label: string;
+    /** Nombre de un ion-icon opcional. */
+    icon?: string;
+    /** Nº de mensajes no leídos (badge). */
+    count?: number;
+}
+/** Mensaje de correo. */
+export interface OkMailMessage {
+    /** Id estable del mensaje. */
+    id: string;
+    /** Id de la carpeta a la que pertenece. */
+    folderId: string;
+    /** Remitente. */
+    from: {
+        name: string;
+        email: string;
+    };
+    /** Destinatarios (correos). */
+    to?: string[];
+    /** Asunto. */
+    subject: string;
+    /** Vista previa (1 línea, atenuada). */
+    preview?: string;
+    /** Cuerpo completo (texto). */
+    body?: string;
+    /** Fecha ISO. */
+    date: string;
+    /** ¿Leído? (si no, se resalta). */
+    read?: boolean;
+    /** ¿Destacado con estrella? */
+    starred?: boolean;
+    /** Adjuntos. */
+    attachments?: Array<{
+        name: string;
+        size?: number;
+    }>;
+}
+/** Textos humanos de ok-mail (i18n; default inglés, override vía prop `labels`). */
+export interface OkMailLabels {
+    /** Botón "Redactar". */
+    compose: string;
+    /** Placeholder del buscador. */
+    searchPlaceholder: string;
+    /** aria-label del punto de no leído. */
+    unread: string;
+    /** aria-label para destacar un mensaje. */
+    star: string;
+    /** aria-label para quitar el destacado de un mensaje. */
+    unstar: string;
+    /** Estado vacío: lista sin mensajes. */
+    noMessages: string;
+    /** Estado vacío: ningún mensaje seleccionado. */
+    selectMessage: string;
+    /** aria-label del botón atrás (móvil). */
+    back: string;
+    /** aria-label de Responder. */
+    reply: string;
+    /** aria-label de Reenviar. */
+    forward: string;
+    /** aria-label de Archivar. */
+    archive: string;
+    /** aria-label de Eliminar. */
+    delete: string;
+    /** Etiqueta "Para:" en la cabecera de lectura. */
+    to: string;
+}
+export declare class OkMail extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Carpetas del buzón. */
+    folders: OkMailFolder[];
+    /** Mensajes (de todas las carpetas; se filtran por `activeFolder`). */
+    messages: OkMailMessage[];
+    /** Id de la carpeta activa. */
+    activeFolder: string;
+    /** Id del mensaje seleccionado (panel de lectura). */
+    activeMessage: string;
+    /** Muestra el buscador en la lista de mensajes. */
+    searchable: boolean;
+    /** Overrides de textos humanos (i18n). Se fusionan sobre los defaults en inglés. */
+    labels: Partial<OkMailLabels>;
+    /** Textos efectivos (defaults inglés + overrides). */
+    private get t();
+    private q;
+    private emit;
+    /** Vista móvil derivada del estado activo: las tabs están siempre arriba, así que el cuerpo
+     * solo alterna entre la lista y la lectura (message si hay mensaje seleccionado, si no list). */
+    private get mobileView();
+    updated(): void;
+    /** Iniciales de un nombre para el avatar (p.ej. "Ana Pérez" → "AP"). */
+    private initials;
+    /** Fecha en formato corto con Intl (hora si es hoy, día/mes si es este año, si no fecha completa). */
+    private fmtDate;
+    /** Tamaño legible de un adjunto (B/KB/MB). */
+    private fmtSize;
+    /** Mensajes de la carpeta activa filtrados por el buscador (preview/asunto/remitente). */
+    private get folderMessages();
+    private onFolderSelect;
+    private onSearch;
+    private onMessageSelect;
+    private onStar;
+    private renderTopbar;
+    private renderTabs;
+    private renderList;
+    private renderReader;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-mail': OkMail;
+    }
+}

package/dist/components/ok-menu/ok-menu.d.ts

@@ -0,0 +1,75 @@
+import { LitElement } from 'lit';
+export interface OkMenuEntry {
+    /** Identificador único de la entrada (clave que se emite en `ok-select`). */
+    id?: string;
+    /** Texto visible de la entrada. */
+    label?: string;
+    /** Nombre de un ionicon (o SVG/`data:` ya resuelto) pintado antes del label. */
+    icon?: string;
+    /** Atajo de teclado mostrado a la derecha en mono (decorativo, p.ej. "⌘S"). */
+    shortcut?: string;
+    /** Pinta la entrada en color de peligro (borrar, etc.). */
+    danger?: boolean;
+    /** Deshabilita la entrada (no seleccionable, no abre submenú). */
+    disabled?: boolean;
+    /** Estado marcado para roles checkbox/radio (dibuja el check a la izquierda). */
+    checked?: boolean;
+    /** Rol ARIA del item: por defecto `menuitem`. */
+    role?: 'menuitem' | 'checkbox' | 'radio';
+    /** Si es `true`, dibuja una línea divisoria en lugar de una entrada. */
+    divider?: boolean;
+    /** Si está presente (sin `id`/acción), dibuja una etiqueta de sección en mayúsculas. */
+    section?: string;
+    /** Hijos: si tiene, la entrada abre un submenú en cascada (chevron, hover/teclado). */
+    children?: OkMenuEntry[];
+}
+/** Lado horizontal/vertical de anclaje del panel respecto al disparador. */
+export type OkMenuAnchor = 'br' | 'bl' | 'tr' | 'tl';
+/** Ancho mínimo del panel. */
+export type OkMenuWidth = 'sm' | 'md' | 'lg';
+/** Modo de disparo: click en el trigger, o contextmenu (click derecho) en el área. */
+export type OkMenuTrigger = 'click' | 'context';
+export declare class OkMenu extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Entradas del menú (array declarativo). */
+    items: OkMenuEntry[];
+    /** Modo de disparo: `click` (sobre el slot) o `context` (click derecho). */
+    trigger: OkMenuTrigger;
+    /** Lado de anclaje en modo click. */
+    anchor: OkMenuAnchor;
+    /** Ancho mínimo del panel. */
+    width: OkMenuWidth;
+    /** Estado abierto/cerrado (reflejado). */
+    open: boolean;
+    /** Volteo horizontal calculado por computeAnchor (true → alinear a la derecha). */
+    private flipEnd;
+    /** Volteo vertical calculado por computeAnchor (true → abrir hacia arriba). */
+    private flipAbove;
+    /** Coordenadas del cursor en modo contextual (relativas al host). */
+    private ctxX;
+    private ctxY;
+    /** id del submenú abierto (uno por nivel raíz). */
+    private openSub;
+    private onDocPointer;
+    private onKeydown;
+    private focusableItems;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private onContextMenu;
+    private onTriggerClick;
+    private openMenu;
+    private close;
+    private measureAnchor;
+    private activate;
+    private isResolvedSvg;
+    private renderIcon;
+    private renderEntry;
+    private toggleSub;
+    private onItemKeydown;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-menu': OkMenu;
+    }
+}

package/dist/components/ok-menubar/ok-menubar.d.ts

@@ -0,0 +1,75 @@
+import { LitElement } from 'lit';
+export interface OkMenuItem {
+    /** Identificador único del item (clave de selección). */
+    id: string;
+    /** Texto visible del item (ignorado si `separator`). */
+    label?: string;
+    /** Nombre de un ionicon opcional, mostrado antes del label. */
+    icon?: string;
+    /** Atajo de teclado mostrado a la derecha (solo decorativo, p.ej. "⌘S"). */
+    shortcut?: string;
+    /** Deshabilita el item (no seleccionable, no abre submenú). */
+    disabled?: boolean;
+    /** Si es `true`, dibuja una línea divisoria en lugar de un item. */
+    separator?: boolean;
+    /** Hijos: si tiene, el item abre un submenú al lado (hover/flecha). */
+    children?: OkMenuItem[];
+}
+export interface OkMenu {
+    /** Identificador único del menú. */
+    id: string;
+    /** Texto visible en la barra (Archivo / Editar / Ver…). */
+    label: string;
+    /** Items del desplegable. */
+    items: OkMenuItem[];
+}
+export interface OkMenubarLabels {
+    /** aria-label y texto del botón hamburguesa móvil. */
+    menu: string;
+}
+export declare class OkMenubar extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Menús de la barra (cada uno con su lista de items). */
+    menus: OkMenu[];
+    /** Textos traducibles (merge sobre los defaults en inglés). */
+    labels: Partial<OkMenubarLabels>;
+    private get t();
+    private openMenuId;
+    private openPath;
+    private activeItemId;
+    private mobileOpen;
+    private accExpanded;
+    private isMobile;
+    private ro?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private readonly onDocClick;
+    private readonly onKeydown;
+    private bind;
+    private unbind;
+    private openMenu;
+    private toggleMenu;
+    private hoverMenu;
+    private closeAll;
+    private emitOpen;
+    private openSub;
+    private hoverItem;
+    private selectItem;
+    private focusableItems;
+    private moveActive;
+    private onMenuKeydown;
+    private cycleTopMenu;
+    private toggleMobile;
+    private toggleAccordion;
+    private renderItem;
+    private renderBar;
+    private renderAccItem;
+    private renderMobile;
+    render(): unknown;
+    protected firstUpdated(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-menubar': OkMenubar;
+    }
+}

package/dist/components/ok-navbar/ok-navbar.d.ts

@@ -0,0 +1,42 @@
+import { LitElement } from 'lit';
+export interface OkNavbarLabels {
+    /** aria-label del botón hamburguesa (abre el menú). */
+    menu: string;
+    /** aria-label del botón de cerrar el panel. */
+    close: string;
+}
+export declare class OkNavbar extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Fija la navbar arriba al hacer scroll. */
+    sticky: boolean;
+    /** Fondo de cristal (translúcido + desenfoque). Combínalo con `sticky`. */
+    glass: boolean;
+    /** Estado del panel móvil (reflejado; controla el ion-modal). */
+    open: boolean;
+    /** Textos i18n (parcial; se mezclan sobre los defaults en inglés). */
+    labels: Partial<OkNavbarLabels>;
+    /** Viewport móvil (≤800px): los slots se proyectan en la barra solo en desktop. */
+    private isMobile;
+    private mq;
+    private modal;
+    private linksHost;
+    private actionsHost;
+    private closeBtn;
+    /** Nodos light-DOM movidos al panel (en orden original) para devolverlos al host. */
+    private movedNodes;
+    private get t();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: Map<PropertyKey, unknown>): void;
+    private onMqChange;
+    private openPanel;
+    private buildModal;
+    private presentPanel;
+    private restoreNodes;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-navbar': OkNavbar;
+    }
+}

package/dist/components/ok-notification-center/ok-notification-center.d.ts

@@ -0,0 +1,79 @@
+import { LitElement } from 'lit';
+/** Variante de color del icono redondo (tinte de estado). */
+export type OkNotifVariant = 'leaf' | 'warn' | 'info' | 'brand';
+/** Una notificación de la bandeja. */
+export interface OkNotification {
+    /** Identificador único (clave de lectura/selección). */
+    id: string;
+    /**
+     * Icono del avatar redondo. Dos formas:
+     *   • NOMBRE de ionicon (p. ej. `checkmark-outline`) → `ion-icon name`;
+     *   • SVG ya resuelto (`<svg…>` o `data:` URI) → `ion-icon icon` (hosts offline/horneados).
+     * Si se omite se usa un icono de campana por defecto.
+     */
+    icon?: string;
+    /** Tinte de estado del avatar (default neutro). */
+    variant?: OkNotifVariant;
+    /** Texto principal. Puede traer HTML simple (<b>…</b>) → se pinta con unsafeHTML controlado. */
+    text: string;
+    /** Línea secundaria mono (contexto, cita, referencia). */
+    meta?: string;
+    /** Marca de tiempo relativa ya formateada por el consumidor (p. ej. "12:42", "ayer"). */
+    time?: string;
+    /** Si es no-leída: marca el punto lateral y cuenta en el badge. */
+    unread?: boolean;
+}
+/** Chip de filtro de la cabecera. */
+export interface OkNotifFilter {
+    /** Identificador del filtro (se emite en `ok-filter`). */
+    id: string;
+    /** Texto visible del chip. */
+    label: string;
+}
+/** Textos humanos (i18n; default inglés, override vía prop `labels`). */
+export interface OkNotifLabels {
+    /** Texto del footer (marcar todas como leídas). */
+    markAllRead: string;
+    /** aria-label del botón de cerrar (X). */
+    close: string;
+    /** Título del estado vacío. */
+    emptyTitle: string;
+    /** Texto del estado vacío. */
+    emptyText: string;
+}
+export declare class OkNotificationCenter extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Notificaciones a mostrar (datos declarativos). */
+    items: OkNotification[];
+    /** Chips de filtro de la cabecera. */
+    filters: OkNotifFilter[];
+    /** Id del filtro activo. */
+    active?: string;
+    /** Abierto/cerrado (modo controlado por el padre). */
+    open: boolean;
+    /** Título de la cabecera. */
+    title: string;
+    /** Textos traducibles (merge sobre los defaults en inglés). */
+    labels: Partial<OkNotifLabels>;
+    private get t();
+    private get unreadCount();
+    private readonly onKeydown;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private isResolvedSvg;
+    private requestClose;
+    private onItemClick;
+    private onMarkAll;
+    private onFilter;
+    protected updated(changed: Map<string, unknown>): void;
+    private renderAvatar;
+    private renderText;
+    private renderItem;
+    private renderEmpty;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-notification-center': OkNotificationCenter;
+    }
+}

package/dist/components/ok-org-chart/ok-org-chart.d.ts

@@ -0,0 +1,67 @@
+import { LitElement } from 'lit';
+/** Un nodo del organigrama (recursivo vía `children`). */
+export interface OrgNode {
+    /** Identificador único (opcional, útil para keys). */
+    id?: string;
+    /** Nombre de la persona/unidad. */
+    name: string;
+    /** Rol o cargo (línea secundaria muted). */
+    role?: string;
+    /** URL de avatar del propio nodo (no usada en el stack de equipo). */
+    avatar?: string;
+    /** Tamaño del equipo que reporta a este nodo → genera el stack de avatares (+N). */
+    team?: number;
+    /** Hijos directos en la jerarquía. */
+    children?: OrgNode[];
+}
+export declare class OkOrgChart extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Nodo raíz del organigrama (con `children` recursivos). */
+    root: OrgNode | null;
+    /** Máximo de avatares mostrados en el stack antes del «+N» (resto). */
+    maxAvatars: number;
+    /** Alto del viewport en px (el organigrama vive dentro y se navega con pan/zoom). */
+    height: number;
+    private tx;
+    private ty;
+    private k;
+    private grabbing;
+    private collapsed;
+    private contentW;
+    private contentH;
+    private fitted;
+    private pointers;
+    private panStart;
+    private pinchStart;
+    private wrapEl;
+    private ro;
+    private userMoved;
+    private layout;
+    /** Renderiza el stack de avatares (+N) para el tamaño de equipo de un nodo. */
+    private renderTeam;
+    /** Iniciales del nombre (1ª letra del primer y último término), para el avatar sin imagen. */
+    private initialsOf;
+    /** Recoge/expande la rama de un nodo y emite `ok-node-toggle`. */
+    private toggle;
+    /** Renderiza un nodo posicionado (HTML absoluto en coordenadas del mundo). */
+    private renderNode;
+    /** Encuadra todo el organigrama en el viewport con un pequeño margen. */
+    fit(): void;
+    /** Recentra el organigrama en el viewport MANTENIENDO el zoom actual. */
+    center(): void;
+    private zoomAround;
+    private zoomBy;
+    private onWheel;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    protected firstUpdated(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    disconnectedCallback(): void;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-org-chart': OkOrgChart;
+    }
+}

package/dist/components/ok-otp/ok-otp.d.ts

@@ -0,0 +1,31 @@
+import { LitElement } from 'lit';
+export interface OkOtpLabels {
+    /** aria-label de cada casilla. Recibe el índice (1-based) y el total. */
+    digitLabel: (index: number, length: number) => string;
+}
+export declare class OkOtp extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Número de casillas de la OTP. */
+    length: number;
+    /** Valor actual (string de dígitos). */
+    value: string;
+    /** Textos traducibles (merge sobre los defaults en inglés). */
+    labels: Partial<OkOtpLabels>;
+    private get t();
+    private firstInput?;
+    private get inputs();
+    private focusAt;
+    private syncFromInputs;
+    private onInput;
+    private onKeydown;
+    private onPaste;
+    private distribute;
+    private digitAt;
+    protected firstUpdated(): void;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-otp': OkOtp;
+    }
+}

package/dist/components/ok-page-header/ok-page-header.d.ts

@@ -0,0 +1,23 @@
+import { LitElement } from 'lit';
+export declare class OkPageHeader extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Título de la página/sección. */
+    heading: string;
+    /** Nivel semántico del heading: 1 (def, h1) | 2 (h2, sub-página). */
+    level: 1 | 2;
+    /** Subtítulo atenuado bajo el título. */
+    description?: string;
+    /** Variante densa para sub-páginas (reflejado para CSS). */
+    compact: boolean;
+    private hasBreadcrumbs;
+    private hasMeta;
+    private hasActions;
+    private hasExtra;
+    private onSlotChange;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-page-header': OkPageHeader;
+    }
+}

package/dist/components/ok-pagination/ok-pagination.d.ts

@@ -0,0 +1,44 @@
+import { LitElement } from 'lit';
+export type PaginationVariant = 'default' | 'compact';
+export declare class OkPagination extends LitElement {
+    static styles: import("lit").CSSResult;
+    /** Total de elementos (no de páginas). */
+    total: number;
+    /** Página actual (base 1). */
+    page: number;
+    /** Tamaño de página (elementos por página). */
+    pageSize: number;
+    /** Nº de páginas vecinas mostradas a cada lado de la activa. */
+    siblingCount: number;
+    /** Nº de páginas fijas mostradas en cada extremo (inicio/fin). */
+    boundaryCount: number;
+    /** Variante visual: numerada completa o compacta (prev/valor/next). */
+    variant: PaginationVariant;
+    /** Muestra el texto informativo "X–Y de Z". */
+    info: boolean;
+    /** Opciones de filas por página; si se pasan, muestra un ion-select. */
+    pageSizeOptions?: number[];
+    /** Etiqueta accesible del nav. */
+    label: string;
+    /** Nº total de páginas (mínimo 1). */
+    private get pageCount();
+    /** Página actual saneada al rango [1, pageCount]. */
+    private get current();
+    /** Construye la lista de tokens (números + elipsis) según sibling/boundary counts. */
+    private get range();
+    /** Rango entero [from, to] como array (vacío si from > to). */
+    private seq;
+    private goTo;
+    private onSizeChange;
+    /** Chevron SVG (izq/der) dibujado a mano. */
+    private chevron;
+    private renderInfo;
+    private renderPageSize;
+    private renderNav;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ok-pagination': OkPagination;
+    }
+}