@groupteknology/vuno 1.0.0 → 2.0.0

package/dist/runtime/app/components/Table/internal/CellBoolean/CellBoolean.vue.d.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'boolean'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellCurrency/CellCurrency.d.vue.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'currency'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellCurrency/CellCurrency.theme.d.ts

@@ -0,0 +1,5 @@
+export declare const cellCurrencyTheme: Record<"cellCurrency", {
+    readonly slots: {
+        readonly base: "tabular-nums";
+    };
+}>;

package/dist/runtime/app/components/Table/internal/CellCurrency/CellCurrency.theme.js

@@ -0,0 +1,4 @@
+import { defineTheme } from "#vuno/utils/theme";
+export const cellCurrencyTheme = defineTheme("cellCurrency", {
+  slots: { base: "tabular-nums" }
+});

package/dist/runtime/app/components/Table/internal/CellCurrency/CellCurrency.vue

@@ -0,0 +1,16 @@
+<script setup>
+import { useLocale, useTheme } from "#vuno/composables/useTheme";
+import { formatCurrency } from "#vuno/utils/format";
+defineOptions({ name: "VunoCellCurrency" });
+const props = defineProps({
+  column: { type: null, required: true },
+  row: { type: Object, required: true },
+  value: { type: null, required: true }
+});
+const locale = useLocale();
+const ui = useTheme("cellCurrency");
+</script>
+
+<template>
+    <span :class="ui.base">{{ formatCurrency(props.value, locale, props.column.currency, props.column.decimals) }}</span>
+</template>

package/dist/runtime/app/components/Table/internal/CellCurrency/CellCurrency.vue.d.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'currency'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellDate/CellDate.d.vue.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'date'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellDate/CellDate.theme.d.ts

@@ -0,0 +1,5 @@
+export declare const cellDateTheme: Record<"cellDate", {
+    readonly slots: {
+        readonly base: "tabular-nums";
+    };
+}>;

package/dist/runtime/app/components/Table/internal/CellDate/CellDate.theme.js

@@ -0,0 +1,4 @@
+import { defineTheme } from "#vuno/utils/theme";
+export const cellDateTheme = defineTheme("cellDate", {
+  slots: { base: "tabular-nums" }
+});

package/dist/runtime/app/components/Table/internal/CellDate/CellDate.vue

@@ -0,0 +1,21 @@
+<script setup>
+import { computed } from "vue";
+import { useLocale, useTheme } from "#vuno/composables/useTheme";
+import { formatDate } from "#vuno/utils/format";
+defineOptions({ name: "VunoCellDate" });
+const props = defineProps({
+  column: { type: null, required: true },
+  row: { type: Object, required: true },
+  value: { type: null, required: true }
+});
+const locale = useLocale();
+const ui = useTheme("cellDate");
+const options = computed(() => ({
+  dateStyle: props.column.dateStyle ?? "medium",
+  ...props.column.timeStyle ? { timeStyle: props.column.timeStyle } : {}
+}));
+</script>
+
+<template>
+    <span :class="ui.base">{{ formatDate(props.value, locale, options) }}</span>
+</template>

package/dist/runtime/app/components/Table/internal/CellDate/CellDate.vue.d.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'date'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellImage/CellImage.d.vue.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'image'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellImage/CellImage.vue

@@ -0,0 +1,24 @@
+<script setup>
+import { computed } from "vue";
+import { getPath } from "#vuno/utils/path";
+import Avatar from "#vuno/components/Avatar/Avatar.vue";
+defineOptions({ name: "VunoCellImage" });
+const props = defineProps({
+  column: { type: null, required: true },
+  row: { type: Object, required: true },
+  value: { type: null, required: true }
+});
+const src = computed(() => props.value === null || props.value === void 0 ? "" : String(props.value));
+const alt = computed(() => {
+  if (props.column.altKey) return String(getPath(props.row, props.column.altKey) ?? "");
+  return props.column.alt ?? "";
+});
+</script>
+
+<template>
+    <Avatar
+        :alt="alt"
+        :size="props.column.size ?? 'md'"
+        :src="src"
+    />
+</template>

package/dist/runtime/app/components/Table/internal/CellImage/CellImage.vue.d.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'image'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellNumber/CellNumber.d.vue.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'number'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellNumber/CellNumber.theme.d.ts

@@ -0,0 +1,5 @@
+export declare const cellNumberTheme: Record<"cellNumber", {
+    readonly slots: {
+        readonly base: "tabular-nums";
+    };
+}>;

package/dist/runtime/app/components/Table/internal/CellNumber/CellNumber.theme.js

@@ -0,0 +1,4 @@
+import { defineTheme } from "#vuno/utils/theme";
+export const cellNumberTheme = defineTheme("cellNumber", {
+  slots: { base: "tabular-nums" }
+});

package/dist/runtime/app/components/Table/internal/CellNumber/CellNumber.vue

@@ -0,0 +1,17 @@
+<script setup>
+import { useLocale, useTheme } from "#vuno/composables/useTheme";
+import { formatNumber } from "#vuno/utils/format";
+defineOptions({ name: "VunoCellNumber" });
+const props = defineProps({
+  column: { type: null, required: true },
+  row: { type: Object, required: true },
+  value: { type: null, required: true }
+});
+const locale = useLocale();
+const ui = useTheme("cellNumber");
+</script>
+
+<template>
+    <!-- `tabular-nums` alinea las cifras en columna; sin ello los dígitos bailan. -->
+    <span :class="ui.base">{{ formatNumber(props.value, locale, props.column.decimals) }}</span>
+</template>

package/dist/runtime/app/components/Table/internal/CellNumber/CellNumber.vue.d.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'number'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellText/CellText.d.vue.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'text'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/CellText/CellText.theme.d.ts

@@ -0,0 +1,13 @@
+export declare const cellTextTheme: Record<"cellText", {
+    readonly slots: {
+        readonly base: "";
+    };
+    readonly variants: {
+        readonly truncate: {
+            readonly false: {};
+            readonly true: {
+                readonly base: "block max-w-[32ch] truncate";
+            };
+        };
+    };
+}>;

package/dist/runtime/app/components/Table/internal/CellText/CellText.theme.js

@@ -0,0 +1,11 @@
+import { defineTheme } from "#vuno/utils/theme";
+export const cellTextTheme = defineTheme("cellText", {
+  slots: { base: "" },
+  /* Solo corta si la columna lo pide, y el ancho es del tema. */
+  variants: {
+    truncate: {
+      false: {},
+      true: { base: "block max-w-[32ch] truncate" }
+    }
+  }
+});

package/dist/runtime/app/components/Table/internal/CellText/CellText.vue

@@ -0,0 +1,16 @@
+<script setup>
+import { computed } from "vue";
+import { useTheme } from "#vuno/composables/useTheme";
+defineOptions({ name: "VunoCellText" });
+const props = defineProps({
+  column: { type: null, required: true },
+  row: { type: Object, required: true },
+  value: { type: null, required: true }
+});
+const text = computed(() => props.value === null || props.value === void 0 ? "" : String(props.value));
+const ui = useTheme("cellText", void 0, () => ({ truncate: props.column.truncate ? "true" : "false" }));
+</script>
+
+<template>
+    <span :class="ui.base">{{ text }}</span>
+</template>

package/dist/runtime/app/components/Table/internal/CellText/CellText.vue.d.ts

@@ -0,0 +1,5 @@
+import type { VunoTableCellProps } from '#vuno/types/table';
+type __VLS_Props = VunoTableCellProps<'text'>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/app/components/Table/internal/TableCell/TableCell.d.vue.ts

@@ -0,0 +1,22 @@
+import type { VunoTableColumn, VunoTableRow } from '#vuno/types/table';
+declare const __VLS_export: <TRow extends VunoTableRow>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        column: VunoTableColumn<TRow>;
+        row: TRow;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/app/components/Table/internal/TableCell/TableCell.vue

@@ -0,0 +1,48 @@
+<script setup>
+import { computed } from "vue";
+import CellBadge from "#vuno/components/Table/internal/CellBadge/CellBadge.vue";
+import CellBoolean from "#vuno/components/Table/internal/CellBoolean/CellBoolean.vue";
+import CellCurrency from "#vuno/components/Table/internal/CellCurrency/CellCurrency.vue";
+import CellDate from "#vuno/components/Table/internal/CellDate/CellDate.vue";
+import CellImage from "#vuno/components/Table/internal/CellImage/CellImage.vue";
+import CellNumber from "#vuno/components/Table/internal/CellNumber/CellNumber.vue";
+import CellText from "#vuno/components/Table/internal/CellText/CellText.vue";
+import { resolveColumnValue } from "#vuno/components/Table/internal/column";
+defineOptions({ name: "VunoTableCell" });
+const props = defineProps({
+  column: { type: Object, required: true },
+  row: { type: null, required: true }
+});
+const value = computed(() => resolveColumnValue(props.column, props.row));
+const cell = computed(() => {
+  const column = props.column;
+  const row = props.row;
+  switch (column.type) {
+    case "badge":
+      return { is: CellBadge, props: { column, row, value: value.value } };
+    case "boolean":
+      return { is: CellBoolean, props: { column, row, value: value.value } };
+    case "currency":
+      return { is: CellCurrency, props: { column, row, value: value.value } };
+    case "date":
+      return { is: CellDate, props: { column, row, value: value.value } };
+    case "image":
+      return { is: CellImage, props: { column, row, value: value.value } };
+    case "number":
+      return { is: CellNumber, props: { column, row, value: value.value } };
+    case "text":
+      return { is: CellText, props: { column, row, value: value.value } };
+    default: {
+      column.type;
+      return { is: CellText, props: { column: { key: column.key, type: "text", ui: column.ui }, row, value: value.value } };
+    }
+  }
+});
+</script>
+
+<template>
+    <component
+        :is="cell.is"
+        v-bind="cell.props"
+    />
+</template>

package/dist/runtime/app/components/Table/internal/TableCell/TableCell.vue.d.ts

@@ -0,0 +1,22 @@
+import type { VunoTableColumn, VunoTableRow } from '#vuno/types/table';
+declare const __VLS_export: <TRow extends VunoTableRow>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        column: VunoTableColumn<TRow>;
+        row: TRow;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/app/components/Table/internal/column.d.ts

@@ -0,0 +1,9 @@
+import type { VunoTableColumn, VunoTableRow } from '#vuno/types/table';
+/**
+ * El valor que muestra una columna.
+ *
+ * Vive aquí y no dentro de la celda porque lo necesitan dos sitios —la celda y
+ * el slot `cell-<key>`—, y si cada uno lo resolviera por su cuenta, una columna
+ * con `value` enseñaría una cosa en la celda y le pasaría otra al slot.
+ */
+export declare function resolveColumnValue<TRow extends VunoTableRow>(column: VunoTableColumn<TRow>, row: TRow): unknown;

package/dist/runtime/app/components/Table/internal/column.js

@@ -0,0 +1,5 @@
+import { getPath } from "#vuno/utils/path";
+export function resolveColumnValue(column, row) {
+  if (column.value) return column.value(row);
+  return getPath(row, column.key);
+}

package/dist/runtime/app/components/Table/internal/query.d.ts

@@ -0,0 +1,18 @@
+import type { VunoTableQuery } from '#vuno/types/table';
+/**
+ * Si un filtro tiene valor de verdad.
+ *
+ * `false` y `0` **son** valores —«inactivos», «sin stock»—, así que solo se
+ * descartan los huecos: lo que no ha llegado, la cadena vacía y una selección
+ * múltiple sin nada elegido.
+ */
+export declare function hasFilterValue(value: unknown): boolean;
+/**
+ * Si la consulta está acotando lo que se enseña.
+ *
+ * Sirve para distinguir «no hay nada» de «no hay nada que case con esto», que
+ * no son lo mismo: lo primero invita a crear el primer registro y lo segundo a
+ * quitar el filtro. Decir «todavía no hay productos» con un buscador puesto es
+ * afirmar algo falso sobre el catálogo, y el que busca se lo cree.
+ */
+export declare function hasActiveQuery(query: Pick<VunoTableQuery, 'filters' | 'search'>): boolean;

package/dist/runtime/app/components/Table/internal/query.js

@@ -0,0 +1,8 @@
+export function hasFilterValue(value) {
+  if (value === void 0 || value === null || value === "") return false;
+  return Array.isArray(value) ? value.length > 0 : true;
+}
+export function hasActiveQuery(query) {
+  if ((query.search ?? "").trim() !== "") return true;
+  return Object.values(query.filters ?? {}).some(hasFilterValue);
+}

package/dist/runtime/app/components/Table/internal/selection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Las claves elegidas de una tabla, y cómo se comparan.
+ *
+ * La selección la escribe el consumidor —`v-model:selection`— y admite números
+ * o cadenas, porque un identificador de una API suele ser un número. Pero la
+ * clave de una fila la calcula `getRowId`, que **siempre devuelve cadena**. Con
+ * las dos cosas mezcladas, `includes` no encuentra nada:
+ *
+ * ```ts
+ * [1, 2].includes('1') // false
+ * ```
+ *
+ * De ahí que la comparación viva aquí y no suelta por los componentes: es la
+ * misma en los cuatro sitios que la necesitan —si una fila está elegida, si lo
+ * están todas las de la página, marcar y desmarcar— y basta con que uno de
+ * ellos la escriba a su manera para que la tabla enseñe casillas vacías sin que
+ * nada falle.
+ *
+ * Lo que entra se devuelve como estaba: si el consumidor dio números, se le
+ * siguen devolviendo los suyos. Normalizar la lista entera a cadenas
+ * arreglaría la comparación y le cambiaría el tipo de los valores por debajo.
+ */
+export type VunoSelectionKey = number | string;
+/** Si esa clave está elegida, comparando como texto. */
+export declare function hasKey(selection: readonly VunoSelectionKey[], key: string): boolean;
+/** Añade las que falten, sin tocar las que ya estaban ni su tipo. */
+export declare function addKeys(selection: readonly VunoSelectionKey[], keys: readonly string[]): VunoSelectionKey[];
+/** Quita esas claves y deja el resto intacto. */
+export declare function removeKeys(selection: readonly VunoSelectionKey[], keys: readonly string[]): VunoSelectionKey[];

package/dist/runtime/app/components/Table/internal/selection.js

@@ -0,0 +1,10 @@
+export function hasKey(selection, key) {
+  return selection.some((value) => String(value) === key);
+}
+export function addKeys(selection, keys) {
+  const nuevas = keys.filter((key) => !hasKey(selection, key));
+  return [...selection, ...nuevas];
+}
+export function removeKeys(selection, keys) {
+  return selection.filter((value) => !keys.includes(String(value)));
+}

package/dist/runtime/app/components/Table/internal/useVunoTable.d.ts

@@ -0,0 +1,93 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { VunoFormDefinition } from '#vuno/types/form';
+import type { VunoTableColumn, VunoTableDefinition, VunoTableFilters, VunoTableQuery, VunoTableRow, VunoTableSortDirection } from '#vuno/types/table';
+/** Un filtro activo, listo para pintarse como chip. */
+type VunoTableActiveFilter = {
+    name: string;
+    label: string;
+    value: string;
+};
+type VunoTableOptions<TRow extends VunoTableRow> = {
+    query: Ref<VunoTableQuery>;
+    selection: Ref<(number | string)[]>;
+    definition: () => VunoTableDefinition<TRow>;
+    total: () => number;
+};
+type VunoTableContext<TRow extends VunoTableRow> = {
+    activeFilters: ComputedRef<VunoTableActiveFilter[]>;
+    columns: ComputedRef<VunoTableRenderColumn<TRow>[]>;
+    filtersDefinition: ComputedRef<VunoFormDefinition>;
+    filtersOpen: Ref<boolean>;
+    /** Copia editable del panel: no llega a la consulta hasta aplicar. */
+    filterState: Ref<VunoTableFilters>;
+    /**
+     * Si lo que se enseña está acotado por una búsqueda o un filtro.
+     *
+     * Es lo que separa «todavía no hay nada» de «nada casa con esto»: sin ello
+     * una tabla filtrada hasta cero diría que no hay datos, que es falso sobre
+     * el conjunto entero.
+     */
+    isFiltered: ComputedRef<boolean>;
+    lastPage: ComputedRef<number>;
+    pageSizes: ComputedRef<number[]>;
+    paginated: ComputedRef<boolean>;
+    rangeEnd: ComputedRef<number>;
+    rangeStart: ComputedRef<number>;
+    search: Ref<string>;
+    searchable: ComputedRef<boolean>;
+    /** La página que se enseña, que no siempre es la que pide la URL. */
+    shownPage: ComputedRef<number>;
+    /**
+     * El total, tal y como lo ve la tabla.
+     *
+     * Se devuelve aunque lo aporte quien llama: una disposición propia que lea
+     * su respuesta directamente se queda sin pie mientras esa respuesta se
+     * revalida, y la corrección de página provoca justo esa revalidación.
+     */
+    total: ComputedRef<number>;
+    applyFilters: () => void;
+    clearFilters: () => void;
+    /** Deja la consulta como al entrar. Es la salida que acompaña a `isFiltered`. */
+    clearQuery: () => void;
+    clearSearch: () => void;
+    clearSelection: () => void;
+    getRowId: (row: TRow) => string;
+    goToPage: (page: number) => void;
+    removeFilter: (name: string) => void;
+    setPageSize: (size: number) => void;
+    sortDirectionFor: (key: string) => null | VunoTableSortDirection;
+    toggleSort: (key: string) => void;
+};
+/**
+ * Una columna lista para pintar: la definición y lo que la disposición necesita
+ * resuelto una vez.
+ *
+ * La columna va **dentro** y no esparcida: `VunoTableColumn` es una unión
+ * discriminada por `type` y esparcirla la aplana, que es justo lo que impide a
+ * la celda saber qué está pintando.
+ */
+export type VunoTableRenderColumn<TRow extends VunoTableRow> = {
+    /** Alineación y clases propias de la columna, para la celda. */
+    cellClass: string;
+    column: VunoTableColumn<TRow>;
+    /** Alineación y ancho, para la cabecera. */
+    headerClass: string;
+    key: string;
+    /** El rótulo ya resuelto; la columna de acciones no lleva salvo que se pida. */
+    label: string;
+    sortable: boolean;
+};
+/**
+ * Toda la lógica de una tabla, sin nada de disposición.
+ *
+ * Vive aparte del componente para que `VTable` sea **una** disposición posible
+ * y no la única: quien necesite los filtros en línea en vez de detrás de un
+ * botón puede escribir su propia plantilla sobre esto, en lugar de esperar a
+ * que el componente crezca un prop más por cada proyecto que no encaja.
+ *
+ * Todavía no se auto-importa —por eso está en `internal/` y no en
+ * `composables/`—: publicarlo congela esta forma, y antes conviene que la haya
+ * usado algo real.
+ */
+export declare function useVunoTable<TRow extends VunoTableRow>(options: VunoTableOptions<TRow>): VunoTableContext<TRow>;
+export {};