@cbm-common/cbm-types 0.0.366 → 0.0.368

package/lib/components/document-editor/lists/document-editor-list.d.ts

@@ -0,0 +1,12 @@
+import { Editor, Extension } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import { DocumentListCollection, DocumentVariablesCatalog } from '../nodes/document-editor-node-types';
+export declare const DocumentListRow: Extension<any, any>;
+export interface DocumentTableRow {
+    position: number;
+    node: ProseMirrorNode;
+}
+export declare function findTableRowAt(editor: Editor, position: number): DocumentTableRow | null;
+export declare function getRowRepeat(editor: Editor, position: number): DocumentListCollection | null;
+export declare function setRowRepeat(editor: Editor, position: number, collection: DocumentListCollection | null): void;
+export declare function insertListTable(editor: Editor, position: number, collection: DocumentListCollection, columns: readonly string[], catalog: DocumentVariablesCatalog): void;

package/lib/components/document-editor/lists/list-panel/document-editor-list-panel.d.ts

@@ -0,0 +1,56 @@
+import { DestroyRef } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { Editor } from '@tiptap/core';
+import { IGeneral } from '../../../../domain/models/general.domain.model';
+import { DocumentListCollection, DocumentVariablesCatalog } from '../../nodes/document-editor-node-types';
+export type DocumentListPanelMode = 'insert' | 'row';
+/**
+ * Contenido del panel lateral de `document-editor` para las tablas de listado:
+ * - `insert`: asistente "Tabla de listado" (categoría y columnas) que inserta la tabla en `position`.
+ * - `row`: "Fila repetible", elige la categoría por la que se repite la fila de tabla que contiene `position`.
+ * Cualquier categoría del backend puede ser un listado; una tabla sin fila repetible es una tabla fija.
+ */
+export declare class DocumentEditorListPanel {
+    private readonly destroyRef;
+    constructor(destroyRef: DestroyRef);
+    editor: import("@angular/core").InputSignal<Editor>;
+    mode: import("@angular/core").InputSignal<DocumentListPanelMode>;
+    /** Posición del documento donde se hizo clic derecho. */
+    position: import("@angular/core").InputSignal<number>;
+    /** Listado que se muestra elegido de inicio en el asistente (el del panel de variables). */
+    initialCollection: import("@angular/core").InputSignal<string | null>;
+    /** Catálogo del editor que contiene el panel. */
+    catalog: import("@angular/core").InputSignal<DocumentVariablesCatalog>;
+    /** Estado de la carga de las variables (las categorías las entrega el backend). */
+    status: import("@angular/core").InputSignal<IGeneral.STATUS>;
+    /** Se insertó la tabla: el panel ya no tiene nada que mostrar. */
+    done: import("@angular/core").OutputEmitterRef<void>;
+    /** Volver a pedir las categorías al backend (la carga falló). */
+    retry: import("@angular/core").OutputEmitterRef<void>;
+    private readonly panelId;
+    readonly collectionInputId: string;
+    readonly columnInputId: string;
+    readonly columnSearchId: string;
+    collection: import("@angular/core").WritableSignal<string | null>;
+    /** Columnas marcadas en el asistente (códigos de valor del nodo de ítem). */
+    columns: import("@angular/core").WritableSignal<string[]>;
+    /** Texto con el que se filtran las columnas (una categoría puede tener decenas de campos). */
+    columnQuery: import("@angular/core").WritableSignal<string>;
+    collectionOptions: import("@angular/core").Signal<{
+        value: DocumentListCollection;
+        label: string;
+    }[]>;
+    columnOptions: import("@angular/core").Signal<import("../../nodes/document-editor-node-types").DocumentNodeOption[]>;
+    visibleColumnOptions: import("@angular/core").Signal<import("../../nodes/document-editor-node-types").DocumentNodeOption[]>;
+    loadingCollections: import("@angular/core").Signal<boolean>;
+    loadFailed: import("@angular/core").Signal<boolean>;
+    collectionLabel: import("@angular/core").Signal<string>;
+    collectionControl: FormControl<string | null>;
+    private readonly _loadEffect;
+    private defaultColumns;
+    onColumnSearch(event: Event): void;
+    clearColumns(): void;
+    isColumnSelected(value: string): boolean;
+    toggleColumn(value: string, event: Event): void;
+    insertTable(): void;
+}

package/lib/components/document-editor/nodes/document-editor-node-attributes.d.ts

@@ -0,0 +1,16 @@
+export interface DocumentNodeBinding {
+    nodeType: string | null;
+    nodeValue: string | null;
+}
+export interface DocumentNodeAttrs extends DocumentNodeBinding {
+    nodeId: string;
+    /** Solo nodos de texto: el texto que tenía antes de convertirse en nodo. */
+    nodeOriginal: string | null;
+}
+export declare function dataAttribute(key: keyof DocumentNodeAttrs): {
+    default: null;
+    parseHTML: (element: HTMLElement) => string | null;
+    renderHTML: (attributes: Record<string, unknown>) => {
+        [x: string]: {};
+    };
+};

package/lib/components/document-editor/nodes/document-editor-node-types.d.ts

@@ -0,0 +1,83 @@
+import { DocumentFieldKind, DocumentSchemaCategory, DocumentVariablesConfig } from '../variables/document-editor-schema';
+export interface DocumentNodeOption {
+    value: string;
+    label: string;
+}
+export interface DocumentNodeCatalog {
+    /** Primer selector del panel: "Tipo de nodo" (las categorías). */
+    types: DocumentNodeOption[];
+    /** Segundo selector, según el tipo elegido: "Valor del nodo" (los campos de esa categoría). */
+    values: Record<string, DocumentNodeOption[]>;
+}
+/** Lo que ofrece UN editor. Inmutable: no se modifica ni se guarda a nivel de módulo. */
+export interface DocumentVariablesCatalog {
+    /** Categorías normalizadas, en el orden del backend. */
+    readonly categories: readonly DocumentSchemaCategory[];
+    /** Opciones de los selectores del panel de nodo (categorías y, por categoría, campos). */
+    readonly nodes: DocumentNodeCatalog;
+    /** Definición de listado por nombre de categoría. */
+    readonly lists: Readonly<Record<string, DocumentListDefinition>>;
+    /** Un grupo por categoría con sus campos como variables (panel "Variables"). */
+    readonly variableGroups: readonly DocumentVariableGroup[];
+    /** Todas las etiquetas `nombre corto · campo` que el panel puede generar. */
+    readonly generatedLabels: ReadonlySet<string>;
+}
+/**
+ * Arma el catálogo de un editor con las categorías ya normalizadas (`toDocumentSchemaCategories`). Cada llamada
+ * devuelve un catálogo nuevo y no guarda nada: lo que arma un editor no lo ve otro editor de la misma página.
+ */
+export declare function createDocumentVariablesCatalog(categories: readonly DocumentSchemaCategory[] | null | undefined, options?: Pick<Partial<DocumentVariablesConfig>, 'defaultListColumns'> | null): DocumentVariablesCatalog;
+/** Catálogo sin variables: el de un editor al que todavía no le llegan. */
+export declare const EMPTY_DOCUMENT_VARIABLES_CATALOG: DocumentVariablesCatalog;
+/** Valores (campos) de un tipo de nodo (categoría). */
+export declare function documentNodeValues(catalog: DocumentVariablesCatalog, type: string): DocumentNodeOption[];
+export declare function toDocumentNodeType(catalog: DocumentVariablesCatalog, value: string | null | undefined): string | null;
+export declare function findDocumentNodeValue(catalog: DocumentVariablesCatalog, type: string | null | undefined, value: string | null | undefined): DocumentNodeOption | null;
+/** Para qué sirve el dato de un campo (texto, número, fecha…), según las categorías ya normalizadas. */
+export declare function documentFieldKind(categories: readonly DocumentSchemaCategory[], type: string, value: string): DocumentFieldKind | null;
+export type DocumentListCollection = string;
+export interface DocumentListDefinition {
+    label: string;
+    /** Categoría de los nodos de texto que se llenan con cada ítem del listado (la misma que el listado). */
+    itemType: string;
+    /** Columnas (campos) que el asistente "Tabla de listado" marca de inicio. */
+    defaultColumns: string[];
+}
+export declare const documentListCollectionOptions: (catalog: DocumentVariablesCatalog) => {
+    value: DocumentListCollection;
+    label: string;
+}[];
+/** Columnas (campos) que el asistente "Tabla de listado" marca de inicio para un listado. */
+export declare function documentListDefaultColumns(catalog: DocumentVariablesCatalog, collection: DocumentListCollection): string[];
+export declare function toDocumentListCollection(value: string | null | undefined): DocumentListCollection | null;
+/** Nombre en español del listado (la descripción de su categoría; si no está en el catálogo, su nombre). */
+export declare function documentListLabel(catalog: DocumentVariablesCatalog, collection: DocumentListCollection): string;
+export interface DocumentVariable {
+    /** Categoría (`client`). */
+    type: string;
+    /** Nombre del campo (`client_business_name`). */
+    value: string;
+    /** Descripción del dato (`Razón social del cliente`). */
+    label: string;
+    /** Lo que muestra el documento (`Cliente · Razón social del cliente`). */
+    fullLabel: string;
+    kind: DocumentFieldKind;
+}
+export interface DocumentVariableGroup {
+    /** Categoría (`client`). */
+    type: string;
+    label: string;
+    variables: DocumentVariable[];
+}
+/** Etiqueta de una variable, o `null` si el tipo o el valor no están en el catálogo. */
+export declare function variableLabel(catalog: DocumentVariablesCatalog, type: string | null | undefined, value: string | null | undefined): string | null;
+export declare const isGeneratedVariableLabel: (catalog: DocumentVariablesCatalog, text: string) => boolean;
+/** Texto sin acentos ni mayúsculas, para buscar. */
+export declare const normalizeSearchText: (text: string) => string;
+/** HTML de una variable (el mismo `span` que guarda el documento): lo usa el arrastre del panel. */
+export declare function variableHtml(variable: DocumentVariable, nodeId: string): string;
+/**
+ * Nodos de texto del HTML que no están enlazados a un dato (les falta el tipo o el valor). Los tramos de un mismo
+ * nodo (cortados por el formato) cuentan una vez.
+ */
+export declare function countIncompleteNodes(html: string): number;

package/lib/components/document-editor/nodes/document-editor-node.d.ts

@@ -0,0 +1,24 @@
+import { Editor, Mark } from '@tiptap/core';
+import type { Mark as ProseMirrorMark } from '@tiptap/pm/model';
+import { DocumentNodeBinding } from './document-editor-node-attributes';
+import { DocumentVariablesCatalog } from './document-editor-node-types';
+export declare const DOCUMENT_NODE_MARK_NAME = "documentNode";
+export declare const DOCUMENT_NODE_SELECTOR = "[data-document-node]";
+export interface DocumentNodeRange extends DocumentNodeBinding {
+    nodeId: string;
+    from: number;
+    to: number;
+    /** Texto actual del nodo. */
+    text: string;
+    /** Texto que tenía antes de convertirse en nodo. */
+    original: string | null;
+    marks: readonly ProseMirrorMark[];
+}
+export declare const DocumentNodeMark: Mark<any, any>;
+export declare function canConvertSelection(editor: Editor): boolean;
+export declare function findDocumentNode(editor: Editor, nodeId: string): DocumentNodeRange | null;
+export declare function convertSelectionToNode(editor: Editor): DocumentNodeRange | null;
+export declare function updateDocumentNodeText(editor: Editor, nodeId: string, text: string): void;
+export declare function updateDocumentNodeBinding(editor: Editor, nodeId: string, binding: DocumentNodeBinding, catalog: DocumentVariablesCatalog): void;
+export declare function insertVariable(editor: Editor, type: string, value: string, catalog: DocumentVariablesCatalog): boolean;
+export declare function removeDocumentNode(editor: Editor, nodeId: string, catalog: DocumentVariablesCatalog): void;

package/lib/components/document-editor/nodes/node-panel/document-editor-node-panel.d.ts

@@ -0,0 +1,34 @@
+import { DestroyRef } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { Editor } from '@tiptap/core';
+import { DocumentVariablesCatalog } from '../document-editor-node-types';
+/**
+ * Contenido del panel lateral de `document-editor`: propiedades del nodo activo (su texto, la categoría y el campo
+ * al que está enlazado; las dos listas salen del catálogo que entrega el backend). Cada cambio del formulario se
+ * aplica al lienzo y lo que se edita en el lienzo se refleja en el formulario.
+ */
+export declare class DocumentEditorNodePanel {
+    private readonly destroyRef;
+    constructor(destroyRef: DestroyRef);
+    editor: import("@angular/core").InputSignal<Editor>;
+    nodeId: import("@angular/core").InputSignal<string>;
+    /** Catálogo del editor que contiene el panel. */
+    catalog: import("@angular/core").InputSignal<DocumentVariablesCatalog>;
+    /** El nodo ya no existe en el documento (se borró su texto o su imagen). */
+    nodeRemoved: import("@angular/core").OutputEmitterRef<void>;
+    private readonly panelId;
+    readonly textInputId: string;
+    readonly typeInputId: string;
+    readonly valueInputId: string;
+    nodeType: import("@angular/core").WritableSignal<string | null>;
+    typeOptions: import("@angular/core").Signal<import("../document-editor-node-types").DocumentNodeOption[]>;
+    valueOptions: import("@angular/core").Signal<import("../document-editor-node-types").DocumentNodeOption[]>;
+    form: FormGroup<{
+        text: FormControl<string>;
+        type: FormControl<string | null>;
+        value: FormControl<string | null>;
+    }>;
+    private readonly _syncWithEditorEffect;
+    private loadNode;
+    private applyBinding;
+}

package/lib/components/document-editor/page/document-editor-page-nodes.d.ts

@@ -0,0 +1,18 @@
+import { Editor, Node } from '@tiptap/core';
+export declare const DOCUMENT_HEADER_NODE_NAME = "documentHeader";
+export declare const DOCUMENT_FOOTER_NODE_NAME = "documentFooter";
+export declare const DOCUMENT_PAGE_BREAK_NODE_NAME = "documentPageBreak";
+export declare const DOCUMENT_FIELD_NODE_NAME = "documentField";
+export type DocumentRegionKind = 'header' | 'footer';
+export type DocumentFieldKind = 'page' | 'pages';
+export declare const DocumentHeader: Node<any, any>;
+export declare const DocumentFooter: Node<any, any>;
+export declare const DocumentPageBreak: Node<any, any>;
+export declare const DocumentField: Node<any, any>;
+export declare const hasRegion: (editor: Editor, kind: DocumentRegionKind) => boolean;
+export declare function isSelectionInRegion(editor: Editor): boolean;
+export declare function focusRegion(editor: Editor, kind: DocumentRegionKind): boolean;
+export declare function addRegion(editor: Editor, kind: DocumentRegionKind): void;
+export declare function removeRegion(editor: Editor, kind: DocumentRegionKind): void;
+export declare function insertPageBreak(editor: Editor): boolean;
+export declare function insertField(editor: Editor, field: DocumentFieldKind): boolean;

package/lib/components/document-editor/page/document-editor-pages.d.ts

@@ -0,0 +1,40 @@
+export type DocumentPageSize = 'letter' | 'legal' | 'executive' | 'a3' | 'a4' | 'a5';
+export type DocumentPageOrientation = 'portrait' | 'landscape';
+export interface DocumentPageDimensions {
+    label: string;
+    width: number;
+    height: number;
+}
+export declare const DOCUMENT_PAGE_SIZES: Record<DocumentPageSize, DocumentPageDimensions>;
+export declare const DEFAULT_DOCUMENT_PAGE_SIZE: DocumentPageSize;
+export declare const DEFAULT_DOCUMENT_PAGE_ORIENTATION: DocumentPageOrientation;
+export interface DocumentPageMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    header: number;
+    footer: number;
+}
+/** Los cuatro márgenes del cuerpo (los que se editan en la lista de márgenes). */
+export type DocumentPageMarginSide = 'top' | 'right' | 'bottom' | 'left';
+export declare const DEFAULT_HEADER_FOOTER_DISTANCE_MM = 12.7;
+export interface DocumentMarginPreset {
+    value: string;
+    label: string;
+    margins: DocumentPageMargins;
+}
+export declare const DEFAULT_DOCUMENT_PAGE_MARGINS: DocumentPageMargins;
+export declare const DOCUMENT_MARGIN_PRESETS: readonly DocumentMarginPreset[];
+export declare const MIN_CONTENT_SIZE_MM = 30;
+export declare const roundMillimeters: (value: number) => number;
+export declare function toDocumentPageMargins(value: Partial<DocumentPageMargins> | null | undefined): DocumentPageMargins;
+export declare function haveSameMargins(left: DocumentPageMargins, right: DocumentPageMargins): boolean;
+export declare function haveSameMarginSides(left: DocumentPageMargins, right: DocumentPageMargins): boolean;
+export declare function clampMargin(value: number, opposite: number, pageSize: number): number;
+export declare function fitMargins(margins: DocumentPageMargins, page: {
+    width: number;
+    height: number;
+}): DocumentPageMargins;
+export declare function toDocumentPageSize(value: string | null | undefined): DocumentPageSize;
+export declare function toDocumentPageOrientation(value: string | null | undefined): DocumentPageOrientation;

package/lib/components/document-editor/page/document-editor-region-guard.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const DocumentRegionGuard: Extension<any, any>;

package/lib/components/document-editor/public-api.d.ts

@@ -0,0 +1,48 @@
+export { CbmDocumentEditorComponent } from './document-editor';
+/**
+ * Lo que un consumidor puede sobrescribir con `[config]`. Es un tipo propio (subconjunto de `AteEditorConfig`) que no
+ * importa `@flogeez/angular-tiptap-editor`: así no queda en `any` en los proyectos que no instalan la librería. Las
+ * claves de `AteEditorConfig` que necesitan tipos de la librería o de Tiptap (`toolbar`, `bubbleMenu`,
+ * `tiptapExtensions`…) quedan fuera a propósito.
+ */
+export interface DocumentEditorConfig {
+    theme?: 'light' | 'dark' | 'auto';
+    mode?: 'classic' | 'seamless';
+    height?: string | number;
+    autofocus?: 'start' | 'end' | 'all' | boolean | number;
+    placeholder?: string;
+    editable?: boolean;
+    minHeight?: string | number;
+    maxHeight?: string | number;
+    fillContainer?: boolean;
+    disabled?: boolean;
+    locale?: string;
+    spellcheck?: boolean;
+    enableOfficePaste?: boolean;
+    showToolbar?: boolean;
+    showFooter?: boolean;
+    showCharacterCount?: boolean;
+    showWordCount?: boolean;
+    showEditToggle?: boolean;
+    showBubbleMenu?: boolean;
+    showImageBubbleMenu?: boolean;
+    showTableMenu?: boolean;
+    showCellMenu?: boolean;
+    downloadImage?: boolean;
+    enableSlashCommands?: boolean;
+    maxCharacters?: number;
+    blockControls?: 'inside' | 'outside' | 'none';
+    floatingToolbar?: boolean;
+}
+export { DOCUMENT_PAGE_SIZES, DEFAULT_DOCUMENT_PAGE_SIZE, DEFAULT_DOCUMENT_PAGE_ORIENTATION, DEFAULT_DOCUMENT_PAGE_MARGINS, fitMargins, toDocumentPageSize, toDocumentPageOrientation, toDocumentPageMargins, } from './page/document-editor-pages';
+export type { DocumentPageSize, DocumentPageOrientation, DocumentPageMargins, DocumentPageDimensions, } from './page/document-editor-pages';
+export { DEFAULT_DOCUMENT_DEFAULTS, toDocumentDefaults } from './format/document-editor-defaults';
+export type { DocumentDefaults } from './format/document-editor-defaults';
+export { DEFAULT_DOCUMENT_VARIABLES_CONFIG, resolveDocumentVariablesConfig, toDocumentSchemaCategories, } from './variables/document-editor-schema';
+export type { DocumentFieldKind, DocumentSchemaCategory, DocumentSchemaCategorySource, DocumentSchemaField, DocumentSchemaFieldSource, DocumentVariablesConfig, DocumentVariablesHiddenField, } from './variables/document-editor-schema';
+export { countIncompleteNodes, documentFieldKind } from './nodes/document-editor-node-types';
+export type { DocumentListCollection } from './nodes/document-editor-node-types';
+export { buildSampleData } from './variables/document-editor-sample-data';
+export { fillDocumentTemplate } from './variables/document-editor-template';
+export type { DocumentTemplateData, DocumentTemplateValues } from './variables/document-editor-template';
+export { registerDocumentEditorI18n } from './i18n/document-editor-i18n';

package/lib/components/document-editor/ribbon/color-menu/document-editor-color-menu.d.ts

@@ -0,0 +1,34 @@
+/** Paleta que muestra el menú: color de fuente (tema de Office) o resaltado (colores de Word). */
+export type DocumentColorPalette = 'text' | 'highlight';
+/** Muestra de color: valor `#RRGGBB` (mayúsculas) y nombre para el `title`/`aria-label`. */
+export interface DocumentColorSwatch {
+    value: string;
+    label: string;
+}
+/**
+ * Contenido del menú de color de `document-editor` (color de fuente o resaltado), al estilo de Word.
+ * Se dibuja dentro de un `popover` del editor: no se abre ni se cierra solo, solo avisa el color elegido
+ * (`null` = el botón "Automático"/"Sin color"). Ningún botón toma el foco, así el editor conserva la selección.
+ */
+export declare class DocumentEditorColorMenu {
+    palette: import("@angular/core").InputSignal<DocumentColorPalette>;
+    /** Texto del botón que quita el color. */
+    noneLabel: import("@angular/core").InputSignal<string>;
+    /** Color aplicado a la selección (`null` si no tiene). Su muestra se marca como activa. */
+    current: import("@angular/core").InputSignal<string | null>;
+    /** Color elegido en `#RRGGBB` (`#rrggbb` desde "Más colores…"), o `null` para quitarlo. */
+    picked: import("@angular/core").OutputEmitterRef<string | null>;
+    private readonly menuId;
+    readonly themeTitleId: string;
+    readonly standardTitleId: string;
+    readonly customInputId: string;
+    readonly themeColors: readonly (readonly DocumentColorSwatch[])[];
+    readonly standardColors: readonly DocumentColorSwatch[];
+    readonly highlightColors: readonly DocumentColorSwatch[];
+    /** Color actual en mayúsculas, para compararlo con las muestras sin importar cómo llegó escrito. */
+    activeColor: import("@angular/core").Signal<string | null>;
+    /** Valor inicial del selector nativo: el color actual si es un `#rrggbb` válido; si no, negro. */
+    customValue: import("@angular/core").Signal<string>;
+    pick(color: string | null): void;
+    pickCustom(event: Event): void;
+}

package/lib/components/document-editor/ribbon/link-menu/document-editor-link-menu.d.ts

@@ -0,0 +1,19 @@
+import { FormControl } from '@angular/forms';
+/**
+ * Contenido del menú "Vínculo" de `document-editor`: dirección del vínculo de la selección. Se dibuja
+ * dentro de un `popover` del editor: no se abre ni se cierra solo, solo avisa la dirección escrita (tal
+ * cual, recortada; quien lo usa la normaliza) o que se quitó el vínculo.
+ */
+export declare class DocumentEditorLinkMenu {
+    /** Dirección del vínculo de la selección (`null` si no tiene). */
+    href: import("@angular/core").InputSignal<string | null>;
+    applied: import("@angular/core").OutputEmitterRef<string>;
+    removed: import("@angular/core").OutputEmitterRef<void>;
+    readonly hrefInputId: string;
+    hrefControl: FormControl<string>;
+    private readonly hrefText;
+    canApply: import("@angular/core").Signal<boolean>;
+    private readonly _syncHrefEffect;
+    apply(event?: Event): void;
+    remove(): void;
+}

package/lib/components/document-editor/ribbon/spinner/document-editor-spinner.d.ts

@@ -0,0 +1,51 @@
+import { FormControl } from '@angular/forms';
+/** Valor confirmado en el campo y si el documento debe recuperar el foco (solo al confirmar con Enter). */
+export interface DocumentSpinnerCommit {
+    value: number;
+    returnFocus: boolean;
+}
+/**
+ * Campo numérico con flechas de la cinta de `document-editor` (como "Izquierda: 0 cm" o "Antes: 0 pt" del grupo
+ * Párrafo de Word): se escribe el valor y se confirma con Enter o al salir del campo, o se sube y baja con las
+ * flechas del campo y del teclado. Solo avisa el valor confirmado (`committed`); quien lo usa lo aplica.
+ */
+export declare class DocumentEditorSpinner {
+    /** Nombre del campo ("Izquierda"). */
+    label: import("@angular/core").InputSignal<string>;
+    /** Unidad que se muestra junto al valor ("cm", "pt"). */
+    unit: import("@angular/core").InputSignal<string>;
+    /** Valor actual (el del párrafo donde está el cursor); `null` si no hay uno. */
+    value: import("@angular/core").InputSignal<number | null>;
+    /** Cuánto suben o bajan las flechas. */
+    step: import("@angular/core").InputSignal<number>;
+    min: import("@angular/core").InputSignal<number>;
+    max: import("@angular/core").InputSignal<number>;
+    /** Decimales que se muestran y se conservan. */
+    decimals: import("@angular/core").InputSignal<number>;
+    /** Icono de Material Symbols que va antes de la etiqueta. */
+    icon: import("@angular/core").InputSignal<string | null>;
+    disabled: import("@angular/core").InputSignal<boolean>;
+    /** Ancho mínimo (px) de la etiqueta: alinea las cajas de varios campos seguidos; con 0 solo ocupa su texto. */
+    labelWidth: import("@angular/core").InputSignal<number>;
+    committed: import("@angular/core").OutputEmitterRef<DocumentSpinnerCommit>;
+    private readonly field;
+    readonly fieldId: string;
+    private dirty;
+    control: FormControl<string>;
+    private readonly _syncValueEffect;
+    private readonly _syncDisabledEffect;
+    private show;
+    private format;
+    markDirty(): void;
+    /**
+     * Descarta lo escrito y muestra `value` (por defecto el valor actual), aunque el campo tenga el foco (un valor nuevo
+     * no lo reescribe mientras se escribe en él). No avisa nada.
+     */
+    discard(value?: number | null): void;
+    private round;
+    private clamp;
+    private read;
+    commit(returnFocus?: boolean): void;
+    stepBy(direction: 1 | -1): void;
+    onKeydown(event: KeyboardEvent): void;
+}

package/lib/components/document-editor/ribbon/symbol-menu/document-editor-symbol-menu.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Contenido del menú "Símbolos" de `document-editor`: cuadrícula de símbolos para insertar en el cursor.
+ * Se dibuja dentro de un `popover` del editor: no se abre ni se cierra solo, solo avisa el símbolo elegido.
+ */
+export declare class DocumentEditorSymbolMenu {
+    picked: import("@angular/core").OutputEmitterRef<string>;
+    readonly titleId: string;
+    readonly symbols: readonly string[];
+    pick(symbol: string): void;
+}

package/lib/components/document-editor/tables/borders/border-menu/document-editor-border-menu.d.ts

@@ -0,0 +1,20 @@
+import type { DocumentBorderTarget } from '../document-editor-table-borders';
+/** Opción del menú: la orden, su icono de Material Symbols y su texto. */
+interface BorderMenuItem {
+    target: DocumentBorderTarget;
+    icon: string;
+    label: string;
+}
+/**
+ * Contenido del menú "Bordes" de `document-editor` (la pestaña de tabla): las diez órdenes de borde de Word. Se
+ * dibuja dentro de un `popover` del editor con `role="menu"`: no se abre ni se cierra solo, solo avisa la orden
+ * elegida (quien lo usa la aplica con `applyTableBorders` y cierra el menú). Ningún botón toma el foco, así el
+ * editor conserva la selección de celdas.
+ */
+export declare class DocumentEditorBorderMenu {
+    /** Orden elegida ("Borde inferior", "Todos los bordes"…). */
+    chosen: import("@angular/core").OutputEmitterRef<DocumentBorderTarget>;
+    readonly groups: readonly (readonly BorderMenuItem[])[];
+    choose(target: DocumentBorderTarget): void;
+}
+export {};

package/lib/components/document-editor/tables/borders/border-style-picker/document-editor-border-style-picker.d.ts

@@ -0,0 +1,13 @@
+import { type DocumentBorderLineStyle } from '../document-editor-table-borders';
+/**
+ * Lista del "Estilo de línea" de la pluma de bordes de `document-editor` (continua, guiones, puntos, doble), cada
+ * estilo con una muestra de la línea. Se dibuja dentro de un `popover` del editor con `role="menu"`: no se abre ni
+ * se cierra solo, solo avisa el estilo elegido. Ningún botón toma el foco, así el editor conserva la selección.
+ */
+export declare class DocumentEditorBorderStylePicker {
+    /** Estilo de la pluma (se marca en la lista); `null` si no hay uno. */
+    current: import("@angular/core").InputSignal<DocumentBorderLineStyle | null>;
+    picked: import("@angular/core").OutputEmitterRef<DocumentBorderLineStyle>;
+    readonly styles: readonly import("../document-editor-table-borders").DocumentBorderLineStyleOption[];
+    pick(style: DocumentBorderLineStyle): void;
+}

package/lib/components/document-editor/tables/borders/border-weight-picker/document-editor-border-weight-picker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Lista del "Grosor de línea" de la pluma de bordes de `document-editor` (de 1/4 a 6 pto), cada grosor con una
+ * muestra de la línea y su nombre. Se dibuja dentro de un `popover` del editor con `role="menu"`: no se abre ni se
+ * cierra solo, solo avisa el grosor elegido (en puntos). Ningún botón toma el foco, así el editor conserva la
+ * selección.
+ */
+export declare class DocumentEditorBorderWeightPicker {
+    /** Grosor de la pluma en puntos (se marca el de la lista que coincide); `null` si no hay uno. */
+    current: import("@angular/core").InputSignal<number | null>;
+    /** Grosor elegido, en puntos. */
+    picked: import("@angular/core").OutputEmitterRef<number>;
+    readonly weights: readonly import("../document-editor-table-borders").DocumentBorderWeightOption[];
+    /** Grosor de la lista que corresponde al actual; `null` si el actual no es de la lista (un borde importado, por ejemplo). */
+    activeWeight: import("@angular/core").Signal<number | null>;
+    pick(weight: number): void;
+}

package/lib/components/document-editor/tables/borders/document-editor-table-border-painter.d.ts

@@ -0,0 +1,14 @@
+import { Extension, type Editor } from '@tiptap/core';
+import { type DocumentBorderPen } from './document-editor-table-borders';
+/** Clase que lleva la hoja mientras "Copiar borde" está activo. */
+export declare const BORDER_PAINTER_CLASS = "document-editor--border-painter";
+export declare const DocumentTableBorderPainter: Extension<any, any>;
+/** ¿Está activo "Copiar borde" en este editor? `false` también si la extensión no está registrada. */
+export declare function isBorderPainterActive(editor: Editor): boolean;
+/**
+ * Activa "Copiar borde" con la pluma `pen`. Llamarla con la herramienta ya activa cambia la pluma (así la cinta
+ * puede cambiar el color o el grosor sin apagarla). Se apaga con `stopBorderPainter` o con Esc.
+ */
+export declare function startBorderPainter(editor: Editor, pen: DocumentBorderPen): void;
+/** Apaga "Copiar borde". */
+export declare function stopBorderPainter(editor: Editor): void;

package/lib/components/document-editor/tables/borders/document-editor-table-borders.d.ts

@@ -0,0 +1,52 @@
+import type { Editor } from '@tiptap/core';
+import type { Transaction } from '@tiptap/pm/state';
+/** Estilos de línea de la pluma. "Sin borde" no es un estilo: es la orden `none` del menú "Bordes". */
+export type DocumentBorderLineStyle = 'solid' | 'dashed' | 'dotted' | 'double';
+/** La pluma de los bordes: cómo se dibuja la línea que se aplica. */
+export interface DocumentBorderPen {
+    style: DocumentBorderLineStyle;
+    /** Grosor en puntos. */
+    width: number;
+    /** Color como `#RRGGBB`. */
+    color: string;
+}
+/** Lado de una celda. */
+export type DocumentBorderSide = 'top' | 'right' | 'bottom' | 'left';
+/**
+ * Órdenes del menú "Bordes":
+ * - `top` / `bottom` / `left` / `right`: ese lado del rectángulo de la selección;
+ * - `outside`: los cuatro lados del rectángulo; `inside`: las líneas internas (horizontales y verticales);
+ * - `insideHorizontal` / `insideVertical`: solo las líneas internas de ese sentido;
+ * - `all`: exteriores e interiores; `none`: quita todos (el borde de cada celda seleccionada y el que la vecina
+ *   tiene frente a ella).
+ */
+export type DocumentBorderTarget = 'bottom' | 'top' | 'left' | 'right' | 'none' | 'all' | 'outside' | 'inside' | 'insideHorizontal' | 'insideVertical';
+export interface DocumentBorderLineStyleOption {
+    value: DocumentBorderLineStyle;
+    label: string;
+}
+export interface DocumentBorderWeightOption {
+    /** Grosor en puntos. */
+    value: number;
+    label: string;
+}
+export declare const DEFAULT_BORDER_PEN: Readonly<DocumentBorderPen>;
+export declare const DOCUMENT_BORDER_LINE_STYLES: readonly DocumentBorderLineStyleOption[];
+export declare const DOCUMENT_BORDER_WEIGHTS: readonly DocumentBorderWeightOption[];
+/** Pluma válida: estilo conocido, grosor entre 1/4 y 6 pt y color `#RRGGBB` en mayúsculas; lo demás vuelve al valor por defecto. */
+export declare function normalizeBorderPen(pen: DocumentBorderPen): DocumentBorderPen;
+/** Valor CSS del borde de la pluma (`0.5pt solid #000000`), el que se escribe en el estilo de la celda. */
+export declare function toBorderCss(pen: DocumentBorderPen): string;
+/**
+ * Aplica un borde a las celdas seleccionadas (o a la celda del cursor), como el menú "Bordes" de Word (ver
+ * `DocumentBorderTarget`). Con `none` quita los bordes y `pen` no se usa. Se escribe también el lado vecino de las
+ * celdas que no están seleccionadas, para que la línea visible sea la misma. Todo en un solo paso del historial.
+ * Con `focus` en `false` el foco se queda donde está.
+ */
+export declare function applyTableBorders(editor: Editor, target: DocumentBorderTarget, pen?: DocumentBorderPen, focus?: boolean): void;
+/**
+ * Aplica la pluma a UN lado de la celda que empieza en `cellPosition` (y al lado de las celdas vecinas que lo tocan),
+ * dentro de la transacción `tr`. Lo usa "Copiar borde". Devuelve si cambió algo; `false` también si la posición no
+ * es la de una celda.
+ */
+export declare function applyCellSideBorder(tr: Transaction, cellPosition: number, side: DocumentBorderSide, pen: DocumentBorderPen): boolean;

package/lib/components/document-editor/tables/document-editor-table-select.d.ts

@@ -0,0 +1,14 @@
+import { Editor } from '@tiptap/core';
+export type DocumentTableSelectPart = 'cell' | 'row' | 'column' | 'table';
+export interface DocumentTableSelectOption {
+    value: DocumentTableSelectPart;
+    label: string;
+    icon: string;
+    hint: string;
+}
+export declare const DOCUMENT_TABLE_SELECT_OPTIONS: readonly DocumentTableSelectOption[];
+/**
+ * Selecciona una parte de la tabla donde está el cursor (la más interna si hay tablas anidadas) y devuelve el foco a la
+ * hoja. Devuelve si hubo algo que seleccionar (el cursor debe estar en una celda).
+ */
+export declare function selectTablePart(editor: Editor, part: DocumentTableSelectPart): boolean;