@groupteknology/vuno 0.1.0

package/dist/runtime/app/theme/index.js

@@ -0,0 +1,210 @@
+export const defaultTheme = {
+  confirm: {
+    slots: {
+      body: "flex items-start gap-3",
+      content: "max-w-md",
+      footer: "justify-end",
+      icon: "shrink-0 size-5"
+    }
+  },
+  fieldArray: {
+    slots: {
+      empty: "text-muted border-default rounded-lg border border-dashed px-4 py-6 text-center text-sm",
+      item: "border-default flex flex-col gap-3 rounded-lg border p-4",
+      itemActions: "flex items-center gap-1",
+      itemFields: "grid w-full grid-cols-12 gap-x-4 gap-y-5",
+      itemHeader: "flex items-center justify-between gap-2",
+      itemLabel: "text-muted text-xs font-medium",
+      root: "flex w-full flex-col gap-3"
+    }
+  },
+  fieldCheckbox: {
+    slots: { root: "w-full" }
+  },
+  fieldColor: {
+    slots: {
+      root: "flex w-full items-center gap-2",
+      swatch: "border-default size-4 rounded-full border"
+    }
+  },
+  fieldEmail: {
+    slots: { root: "w-full" }
+  },
+  fieldFile: {
+    slots: { base: "min-w-0", root: "w-full" }
+  },
+  fieldNumber: {
+    slots: { root: "w-full" }
+  },
+  fieldPassword: {
+    slots: { root: "w-full" }
+  },
+  fieldRadio: {
+    slots: { root: "w-full" }
+  },
+  fieldSelect: {
+    // USelectMenu no tiene slot `root`: su raíz es `base`.
+    slots: { base: "w-full" }
+  },
+  fieldSlug: {
+    slots: { root: "w-full", trailing: "pe-1" }
+  },
+  fieldText: {
+    slots: { root: "w-full" }
+  },
+  fieldTextarea: {
+    slots: { root: "w-full" }
+  },
+  form: {
+    slots: {
+      base: "@container relative flex w-full flex-col gap-4",
+      footer: "flex w-full items-center justify-between gap-4 ",
+      sections: "grid w-full grid-cols-12 gap-x-4 gap-y-5",
+      tabs: "w-full",
+      // Separa el panel de la barra de pestañas, siguiendo el mismo
+      // ritmo vertical que el `gap-y-5` entre filas de campos.
+      tabsContent: "w-full pt-5"
+    }
+  },
+  formField: {
+    slots: { root: "w-full" }
+  },
+  formModal: {
+    slots: {
+      // Un formulario no cabe cómodo en el `max-w-lg` que trae UModal.
+      content: "max-w-3xl",
+      // Acciones a los extremos: descartar a la izquierda, guardar a la derecha.
+      footer: "justify-between"
+    }
+  },
+  formSection: {
+    slots: {
+      description: "mt-1 text-muted",
+      header: "col-span-12 flex min-w-0 flex-col",
+      /**
+       * El hueco horizontal es fijo y estrecho por geometría: doce
+       * columnas son once huecos, así que el grid nunca puede medir
+       * menos de `11 × gap-x`. Con `gap-6` eso son 264px que no caben
+       * en una sección a media anchura dentro de un modal, por mucho
+       * que su contenido pueda encoger; con `gap-x-4` son 176px, que sí.
+       *
+       * Deliberadamente no se escala con una container query sobre la
+       * propia sección: el ancho de la sección depende entonces de un
+       * gap que depende del ancho, y el navegador entra en un bucle de
+       * layout. El hueco vertical, que no está sujeto a esa cuenta, sí
+       * puede ser mayor.
+       */
+      /** Sección dentro de una pestaña: sin marco, porque ya lo pone el panel. */
+      plain: "grid w-full grid-cols-12 gap-x-4 gap-y-5",
+      root: "border-default grid w-full grid-cols-12 gap-x-4 gap-y-5 rounded-lg border p-4",
+      title: "text-highlighted font-semibold"
+    }
+  },
+  page: {
+    slots: {
+      body: "flex w-full flex-col gap-7 px-4 py-6 sm:px-6 sm:py-8 lg:px-10 lg:py-10",
+      breadcrumb: "hidden min-w-0 sm:block",
+      // Medida acotada: a pantalla completa, un párrafo a todo lo ancho
+      // pasa de las 150 letras por línea y deja de leerse.
+      description: "text-muted max-w-prose text-sm",
+      heading: "flex flex-col gap-2",
+      navbar: "border-default bg-default/90 border-b backdrop-blur-xl",
+      navbarLeft: "min-w-0 gap-1",
+      // El panel no pone padding: lo pone `body`, que es quien conoce el ritmo.
+      panelBody: "p-0 sm:p-0",
+      title: "text-highlighted text-2xl font-bold tracking-tight sm:text-3xl"
+    }
+  },
+  state: {
+    slots: {
+      actions: "mt-3 empty:hidden",
+      hint: "text-muted max-w-prose text-sm",
+      icon: "size-8 shrink-0",
+      root: "flex flex-col items-center gap-1 px-4 py-10 text-center",
+      title: "text-highlighted font-medium"
+    }
+  },
+  table: {
+    slots: {
+      chips: "flex flex-wrap items-center gap-2",
+      filtersBody: "flex flex-col gap-4",
+      filtersFooter: "flex items-center justify-between gap-2",
+      footer: "flex flex-wrap items-center justify-between gap-4 px-1",
+      meta: "text-muted flex items-center gap-2 text-sm",
+      root: "flex w-full flex-col gap-4",
+      search: "w-full sm:max-w-xs",
+      selection: "bg-elevated/50 flex items-center justify-between gap-2 rounded-lg px-3 py-2 text-sm",
+      table: "min-w-full",
+      /**
+       * Nuxt UI solo aplica hover a las filas con `data-selectable`, que
+       * son las que reciben un manejador de selección. Aquí se aplica
+       * siempre, y con su misma utilidad semántica para que el color lo
+       * siga decidiendo el tema del proyecto.
+       */
+      tbody: "[&>tr]:hover:bg-elevated/50 [&>tr]:transition-colors",
+      td: "",
+      th: "",
+      toolbar: "flex flex-wrap items-center justify-between gap-2",
+      toolbarActions: "flex items-center gap-2"
+    }
+  }
+};
+export const defaultIcons = {
+  actions: "lucide:ellipsis-vertical",
+  addItem: "lucide:plus",
+  clearSearch: "lucide:x",
+  confirm: "lucide:triangle-alert",
+  empty: "lucide:inbox",
+  failure: "lucide:triangle-alert",
+  fileMoveDown: "lucide:chevron-down",
+  fileMoveUp: "lucide:chevron-up",
+  fileRemove: "lucide:x",
+  fileUpload: "lucide:image",
+  filter: "lucide:list-filter",
+  removeItem: "lucide:trash-2",
+  retry: "lucide:refresh-cw",
+  search: "lucide:search",
+  slugEdit: "lucide:pencil",
+  slugReset: "lucide:x",
+  sort: "lucide:chevrons-up-down",
+  sortAsc: "lucide:arrow-up",
+  sortDesc: "lucide:arrow-down"
+};
+export const defaultMessages = {
+  addItem: "A\xF1adir",
+  applyFilters: "Aplicar",
+  cancel: "Cancelar",
+  clearFilters: "Limpiar filtros",
+  clearSearch: "Limpiar b\xFAsqueda",
+  clearSelection: "Limpiar",
+  confirm: "Confirmar",
+  confirmDescription: "Esta acci\xF3n no se puede deshacer.",
+  confirmTitle: "\xBFQuieres continuar?",
+  created: "Creado correctamente",
+  deleted: "Eliminado correctamente",
+  deleteFailed: "No se pudo eliminar",
+  emptyArray: "Todav\xEDa no hay elementos",
+  emptyHint: "",
+  emptyTable: "No hay resultados",
+  failureHint: "Vuelve a intentarlo en un momento.",
+  failureTitle: "No pudimos cargar los datos",
+  fileMoveDown: "Bajar",
+  fileMoveUp: "Subir",
+  fileRemove: "Eliminar",
+  filters: "Filtros",
+  filtersTitle: "Filtrar resultados",
+  of: "de",
+  removeItem: "Eliminar elemento",
+  retry: "Reintentar",
+  rowActions: "Acciones",
+  rowSelected: "fila seleccionada",
+  rowsSelected: "filas seleccionadas",
+  save: "Guardar",
+  saveFailed: "No se pudo guardar",
+  searchPlaceholder: "Buscar...",
+  selectPlaceholder: "Selecciona una opci\xF3n",
+  showing: "Mostrando",
+  slugEdit: "Editar el slug a mano",
+  slugReset: "Volver al slug autom\xE1tico",
+  updated: "Guardado correctamente"
+};

package/dist/runtime/app/types/app-config.d.ts

@@ -0,0 +1,8 @@
+import type { VunoAppConfig } from './theme.js';
+declare module '@nuxt/schema' {
+    interface AppConfigInput {
+        /** Configuración del módulo: tema por componente, iconos y textos. */
+        vuno?: VunoAppConfig;
+    }
+}
+export {};

package/dist/runtime/app/types/app-config.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/app/types/confirm.d.ts

@@ -0,0 +1,11 @@
+import type { VunoColor } from './table.js';
+export type VunoConfirmOptions = {
+    /** Texto del botón de cancelar. */
+    cancelLabel?: string;
+    /** Color del botón que confirma; `error` para acciones destructivas. */
+    color?: VunoColor;
+    confirmLabel?: string;
+    description?: string;
+    icon?: string;
+    title?: string;
+};

package/dist/runtime/app/types/crud.d.ts

@@ -0,0 +1,64 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { VunoTableFailure, VunoTableQuery, VunoTableRow } from './table.js';
+/** Respuesta de un listado paginado en servidor. */
+export type VunoCrudPage<TRow> = {
+    data: TRow[];
+    total: number;
+};
+export type VunoCrudMessages = {
+    created: string;
+    createFailed: string;
+    deleted: string;
+    deleteFailed: string;
+    updated: string;
+    updateFailed: string;
+};
+export type VunoCrudOptions<TRow extends VunoTableRow, TForm> = {
+    /**
+     * Clave base de la caché. La consulta se añade automáticamente, así que
+     * cada página, filtro y orden se cachean por separado.
+     */
+    key: readonly unknown[] | string;
+    messages?: Partial<VunoCrudMessages>;
+    /** Estado de consulta compartido con la tabla. */
+    query?: Ref<VunoTableQuery>;
+    /** Campo que identifica la fila. Por defecto `id`. */
+    rowKey?: string;
+    create?: (form: TForm) => Promise<unknown>;
+    /** Estado inicial del formulario al dar de alta. */
+    emptyForm: () => TForm;
+    list: (query: VunoTableQuery) => Promise<VunoCrudPage<TRow>>;
+    remove?: (row: TRow) => Promise<unknown>;
+    /** Convierte una fila en el estado del formulario al editar. */
+    toForm?: (row: TRow) => TForm;
+    update?: (id: number | string, form: TForm) => Promise<unknown>;
+};
+/**
+ * Lo que devuelve `useVunoCrud`. Se declara en vez de inferirse porque el tipo
+ * inferido arrastra internos de Vue y no se puede publicar.
+ */
+export type VunoCrud<TRow extends VunoTableRow, TForm> = {
+    confirmOpen: Ref<boolean>;
+    /** Fila pendiente de confirmar su borrado. */
+    deleting: Ref<null | TRow>;
+    /** Fila en edición; `null` significa alta. */
+    editing: Ref<null | TRow>;
+    failure: ComputedRef<undefined | VunoTableFailure>;
+    formOpen: Ref<boolean>;
+    isDeleting: Ref<boolean>;
+    isPending: Ref<boolean>;
+    isSaving: Ref<boolean>;
+    items: ComputedRef<TRow[]>;
+    query: Ref<VunoTableQuery>;
+    state: Ref<TForm>;
+    total: ComputedRef<number>;
+    /** Pide confirmación para borrar una fila. */
+    askDelete: (row: TRow) => void;
+    confirmDelete: () => void;
+    /** Fuerza el refresco del listado. */
+    invalidate: () => void;
+    openCreate: () => void;
+    openEdit: (row: TRow) => void;
+    refetch: () => unknown;
+    submit: () => void;
+};

package/dist/runtime/app/types/field.d.ts

@@ -0,0 +1,121 @@
+import type { ResponsiveColumns, ResponsiveColumnSpan } from './responsive.js';
+type WithType<TField, TType extends string> = TField & {
+    type: TType;
+};
+export type VunoFieldColumns = ResponsiveColumns | ResponsiveColumnSpan;
+export type VunoFieldSize = 'lg' | 'md' | 'sm' | 'xl' | 'xs';
+export type VunoFieldOrientation = 'horizontal' | 'vertical';
+export type VunoFieldSlots = Record<string, string | string[] | undefined>;
+/** Valor que puede tomar una opción de lista. */
+export type VunoFieldOptionValue = boolean | null | number | string;
+/** Opción de los campos con lista (select, radio). */
+export type VunoFieldOption = {
+    description?: string;
+    disabled?: boolean;
+    icon?: string;
+    label: string;
+    value: VunoFieldOptionValue;
+};
+/**
+ * Props comunes a todos los campos: layout dentro del grid, metadatos de
+ * `UFormField` y los dos puntos de escape de estilo (`class` y `ui`).
+ */
+export type VunoFieldBase = {
+    name: string;
+    class?: string;
+    columns?: VunoFieldColumns;
+    description?: string;
+    disabled?: boolean;
+    help?: string;
+    hint?: string;
+    label?: string;
+    required?: boolean;
+    size?: VunoFieldSize;
+    ui?: VunoFieldSlots;
+};
+/**
+ * Lista de grupos de campos repetibles (variantes, líneas, contactos...).
+ *
+ * El tipo es recursivo a propósito: dentro de un array puede haber otro, y los
+ * valores se guardan en el estado como `nombre.0.campo`, que es el mismo
+ * formato de ruta que usan los errores de validación.
+ */
+export type VunoFieldArray = VunoFieldBase & {
+    addLabel?: string;
+    fields: VunoField[];
+    /** Número máximo de elementos; al alcanzarlo se desactiva añadir. */
+    max?: number;
+    /** Número mínimo; por debajo no se puede eliminar. */
+    min?: number;
+    sortable?: boolean;
+};
+export type VunoFieldCheckbox = VunoFieldBase & {
+    indeterminate?: boolean;
+};
+export type VunoFieldColor = VunoFieldBase & {
+    placeholder?: string;
+};
+export type VunoFieldEmail = VunoFieldBase & {
+    autocomplete?: string;
+    autofocus?: boolean;
+    icon?: string;
+    placeholder?: string;
+};
+export type VunoFieldFile = VunoFieldBase & {
+    accept?: string;
+    dropzone?: boolean;
+    layout?: 'grid' | 'list';
+    multiple?: boolean;
+    reorderable?: boolean;
+};
+export type VunoFieldNumber = VunoFieldBase & {
+    max?: number;
+    min?: number;
+    orientation?: VunoFieldOrientation;
+    placeholder?: string;
+    step?: number;
+};
+export type VunoFieldPassword = VunoFieldBase & {
+    autocomplete?: string;
+    autofocus?: boolean;
+    placeholder?: string;
+};
+export type VunoFieldRadio = VunoFieldBase & {
+    items: VunoFieldOption[];
+    orientation?: VunoFieldOrientation;
+};
+export type VunoFieldSelect = VunoFieldBase & {
+    items: VunoFieldOption[];
+    multiple?: boolean;
+    placeholder?: string;
+    searchable?: boolean;
+};
+export type VunoFieldSlug = VunoFieldBase & {
+    placeholder?: string;
+    /** Campo del que se deriva el slug automáticamente. */
+    source: string;
+};
+export type VunoFieldText = VunoFieldBase & {
+    autocomplete?: string;
+    autofocus?: boolean;
+    icon?: string;
+    maxlength?: number;
+    placeholder?: string;
+};
+export type VunoFieldTextarea = VunoFieldBase & {
+    autoresize?: boolean;
+    maxrows?: number;
+    placeholder?: string;
+    rows?: number;
+};
+/**
+ * Unión discriminada por `type`. Es lo que consume `VunoFormDefinition`, de modo
+ * que cada campo de la definición queda tipado con sus propios props.
+ */
+export type VunoField = WithType<VunoFieldArray, 'array'> | WithType<VunoFieldCheckbox, 'checkbox'> | WithType<VunoFieldColor, 'color'> | WithType<VunoFieldEmail, 'email'> | WithType<VunoFieldFile, 'file'> | WithType<VunoFieldNumber, 'number'> | WithType<VunoFieldPassword, 'password'> | WithType<VunoFieldRadio, 'radio'> | WithType<VunoFieldSelect, 'select'> | WithType<VunoFieldSlug, 'slug'> | WithType<VunoFieldText, 'text'> | WithType<VunoFieldTextarea, 'textarea'>;
+export type VunoFieldType = VunoField['type'];
+/** Extrae los props de un tipo concreto de campo: `VunoFieldOf<'slug'>`. */
+export type VunoFieldOf<TType extends VunoFieldType> = Extract<VunoField, {
+    type: TType;
+}>;
+export {};

package/dist/runtime/app/types/form.d.ts

@@ -0,0 +1,39 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+import type { VunoField, VunoFieldColumns, VunoFieldSize } from './field.js';
+/** Cómo se disponen las secciones del formulario. */
+export type VunoFormLayout = 'sections' | 'tabs';
+export type VunoFormSection = {
+    id: string;
+    columns?: VunoFieldColumns;
+    description?: string;
+    /** Campos de la sección, tipados por la unión discriminada `VunoField`. */
+    fields: VunoField[];
+    /** Icono de la pestaña cuando el formulario usa `layout: 'tabs'`. */
+    icon?: string;
+    title?: string;
+};
+export type VunoFormDefinition = {
+    /**
+     * `tabs` convierte cada sección en una pestaña, usando su `title` como
+     * rótulo. Útil en formularios largos y dentro de un modal.
+     */
+    layout?: VunoFormLayout;
+    sections: VunoFormSection[];
+    /** Tamaño aplicado a los campos que no declaran el suyo. */
+    size?: VunoFieldSize;
+};
+export type VunoFormState = Record<string, unknown>;
+export interface VunoFormContext<TState extends VunoFormState = VunoFormState> {
+    dirty: ComputedRef<boolean>;
+    initialState: TState;
+    size: ComputedRef<undefined | VunoFieldSize>;
+    touched: Record<string, boolean>;
+    getValue<TValue = unknown>(name: string): TValue | undefined;
+    isDirty(name?: string): boolean;
+    isTouched(name: string): boolean;
+    reset(): void;
+    resetField(name: string): void;
+    setTouched(name: string, touched?: boolean): void;
+    setValue<TValue = unknown>(name: string, value: TValue): void;
+}
+export declare const vunoFormInjectionKey: InjectionKey<VunoFormContext>;

package/dist/runtime/app/types/form.js

@@ -0,0 +1 @@
+export const vunoFormInjectionKey = Symbol("vuno-form");

package/dist/runtime/app/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './app-config.js';
+export type * from './confirm';
+export type * from './crud';
+export type * from './field';
+export type * from './form';
+export type * from './page';
+export type * from './responsive';
+export type * from './table';
+export type * from './theme';

package/dist/runtime/app/types/index.js

@@ -0,0 +1 @@
+export * from "./app-config.js";

package/dist/runtime/app/types/page.d.ts

@@ -0,0 +1,6 @@
+/** Elemento de la miga de pan; se corresponde con el de Nuxt UI. */
+export type VunoBreadcrumbItem = {
+    icon?: string;
+    label?: string;
+    to?: string;
+};

package/dist/runtime/app/types/responsive.d.ts

@@ -0,0 +1,8 @@
+export type ResponsiveColumnSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+export type ResponsiveColumns = {
+    xs?: ResponsiveColumnSpan;
+    sm?: ResponsiveColumnSpan;
+    md?: ResponsiveColumnSpan;
+    lg?: ResponsiveColumnSpan;
+    xl?: ResponsiveColumnSpan;
+};

package/dist/runtime/app/types/table.d.ts

@@ -0,0 +1,130 @@
+import type { VunoField, VunoFieldSlots } from './field.js';
+type WithType<TColumn, TType extends string> = TColumn & {
+    type: TType;
+};
+export type VunoTableSortDirection = 'asc' | 'desc';
+export type VunoTableSort = {
+    column: string;
+    direction: VunoTableSortDirection;
+};
+/**
+ * Estado de consulta de la tabla. Es el `v-model:query` y la única fuente de
+ * verdad: en modo servidor el consumidor observa este objeto, pide su página
+ * y devuelve `data` y `total`.
+ */
+export type VunoTableFilters = Record<string, unknown>;
+export type VunoTableQuery = {
+    /** Valores del panel de filtros, indexados por el `name` de cada campo. */
+    filters: VunoTableFilters;
+    page: number;
+    pageSize: number;
+    search: string;
+    sort: null | VunoTableSort;
+};
+/**
+ * Fallo de la consulta, con el reintento DENTRO. Es un objeto y no dos props
+ * sueltas a propósito: así no se puede pintar un error sin ofrecer salida.
+ *
+ * Existe porque sin él una consulta fallida se normaliza a lista vacía
+ * (`data ?? []`) y la tabla dice «No hay resultados»: afirma que no hay nada
+ * cuando lo que pasa es que no se pudo saber.
+ */
+export type VunoTableFailure = {
+    hint?: string;
+    title?: string;
+    retry: () => void;
+};
+/** Qué mostrar cuando la consulta va bien y no hay ninguna fila. */
+export type VunoTableEmpty = {
+    hint?: string;
+    icon?: string;
+    title?: string;
+};
+export type VunoTableAlign = 'center' | 'end' | 'start';
+export type VunoTableRow = Record<string, unknown>;
+/** Color semántico de Nuxt UI; el proyecto consumidor decide qué tono es cada uno. */
+export type VunoColor = 'error' | 'info' | 'neutral' | 'primary' | 'secondary' | 'success' | 'warning';
+/**
+ * Nota: no hay `searchable` por columna. La búsqueda la resuelve el endpoint,
+ * que es quien sabe sobre qué campos puede buscar; declararlo aquí sugeriría
+ * que la tabla filtra, y no lo hace.
+ */
+export type VunoTableColumnBase = {
+    align?: VunoTableAlign;
+    class?: string;
+    /** Ruta del valor en la fila. Admite anidado: `'proveedor.nombre'`. */
+    key: string;
+    label?: string;
+    sortable?: boolean;
+    ui?: VunoFieldSlots;
+    width?: string;
+};
+export type VunoTableColumnText = VunoTableColumnBase & {
+    truncate?: boolean;
+};
+export type VunoTableColumnNumber = VunoTableColumnBase & {
+    decimals?: number;
+};
+export type VunoTableColumnCurrency = VunoTableColumnBase & {
+    currency?: string;
+    decimals?: number;
+};
+export type VunoTableColumnDate = VunoTableColumnBase & {
+    dateStyle?: 'full' | 'long' | 'medium' | 'short';
+    timeStyle?: 'full' | 'long' | 'medium' | 'short';
+};
+export type VunoTableColumnBoolean = VunoTableColumnBase & {
+    falseLabel?: string;
+    trueLabel?: string;
+};
+/** Traduce el valor crudo a una etiqueta con color, p. ej. estados. */
+export type VunoTableBadgeMap = Record<string, {
+    color?: VunoColor;
+    label?: string;
+}>;
+export type VunoTableColumnBadge = VunoTableColumnBase & {
+    color?: VunoColor;
+    map?: VunoTableBadgeMap;
+};
+export type VunoTableColumnImage = VunoTableColumnBase & {
+    alt?: string;
+    /** Clave de la fila de la que sacar el texto alternativo. */
+    altKey?: string;
+    size?: 'lg' | 'md' | 'sm' | 'xs';
+};
+/** Delega el contenido en el slot `cell-<key>`. */
+export type VunoTableColumnCustom = VunoTableColumnBase;
+export type VunoTableAction<TRow extends VunoTableRow = VunoTableRow> = {
+    onSelect: (row: TRow) => void;
+    color?: VunoColor;
+    icon?: string;
+    label: string;
+    /** Dibuja un separador encima de la acción. */
+    separator?: boolean;
+    disabled?: (row: TRow) => boolean;
+    /** Oculta la acción para esa fila concreta. */
+    hidden?: (row: TRow) => boolean;
+};
+export type VunoTableColumnActions<TRow extends VunoTableRow = VunoTableRow> = VunoTableColumnBase & {
+    actions: VunoTableAction<TRow>[];
+};
+/** Unión discriminada por `type`, igual que `VunoField` en los formularios. */
+export type VunoTableColumn<TRow extends VunoTableRow = VunoTableRow> = WithType<VunoTableColumnActions<TRow>, 'actions'> | WithType<VunoTableColumnBadge, 'badge'> | WithType<VunoTableColumnBoolean, 'boolean'> | WithType<VunoTableColumnCurrency, 'currency'> | WithType<VunoTableColumnCustom, 'custom'> | WithType<VunoTableColumnDate, 'date'> | WithType<VunoTableColumnImage, 'image'> | WithType<VunoTableColumnNumber, 'number'> | WithType<VunoTableColumnText, 'text'>;
+export type VunoTableColumnType = VunoTableColumn['type'];
+export type VunoTableDefinition<TRow extends VunoTableRow = VunoTableRow> = {
+    columns: VunoTableColumn<TRow>[];
+    /** Texto e icono cuando no hay ninguna fila. */
+    empty?: VunoTableEmpty;
+    /**
+     * Campos del panel lateral de filtros. Son los mismos de un formulario, así
+     * que un filtro se declara igual que se declara un campo.
+     */
+    filters?: VunoField[];
+    /** Tamaños ofrecidos en el selector de filas por página. */
+    pageSizes?: number[];
+    /** Campo que identifica la fila; se usa como clave de selección. */
+    rowKey?: string;
+    searchPlaceholder?: string;
+    selectable?: boolean;
+};
+export {};