@interware/content-generator 0.4.3 → 0.5.0

package/dist/admin/src/features/library/useLibraryApi.d.ts

@@ -0,0 +1,34 @@
+import type { LibraryFile } from './uploadApi';
+/** Cliente de la biblioteca conectado al panel (sesión y notificaciones de Strapi), con raíz en «Generated». */
+export declare const useLibraryApi: () => {
+    api: {
+        dataUrlOf: (file: LibraryFile) => Promise<string>;
+        download: (file: LibraryFile) => Promise<void>;
+        saveBlob: (blob: Blob, name: string, folderId: number | null) => Promise<LibraryFile[]>;
+        getTree(): Promise<import("./model").FolderNode[]>;
+        getCounts(): Promise<import("./uploadApi").FolderCounts>;
+        listFiles(folderId: number | null, { mimes }?: {
+            mimes?: string[] | undefined;
+        }): Promise<LibraryFile[]>;
+        listRecent({ folderIds, mimes, limit }: {
+            folderIds: number[];
+            mimes?: string[] | undefined;
+            limit: number;
+        }): Promise<LibraryFile[]>;
+        createFolder(name: string, parent: number | null): Promise<import("./model").FolderNode>;
+        renameFolder(id: number, name: string, parent: number | null): Promise<void>;
+        uploadFiles(files: File[], folderId: number | null): Promise<LibraryFile[]>;
+        renameFile(file: Pick<LibraryFile, "caption" | "id" | "name" | "folder" | "alternativeText">, name: string): Promise<void>;
+        replaceFile(id: number, file: File): Promise<void>;
+        move({ fileIds, folderIds }: {
+            fileIds?: number[] | undefined;
+            folderIds?: number[] | undefined;
+        }, destinationFolderId: number | null): Promise<void>;
+        remove({ fileIds, folderIds }: {
+            fileIds?: number[] | undefined;
+            folderIds?: number[] | undefined;
+        }): Promise<void>;
+        deleteFolderSafely: (tree: import("./model").FolderNode[], folderId: number) => Promise<void>;
+    };
+    notify: (type: 'success' | 'danger' | 'warning', message: string) => void;
+};

package/dist/admin/src/features/templates/editor/ColorField.d.ts

@@ -0,0 +1,11 @@
+interface ColorFieldProps {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+}
+/**
+ * Selector de color (snowflake: el DS no tiene uno). Muestras de la paleta InterWare y, para casos
+ * puntuales, el selector nativo del navegador.
+ */
+export declare const ColorField: ({ label, value, onChange }: ColorFieldProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/Editor.d.ts

@@ -0,0 +1,19 @@
+import type { ImageLayer, Layer, Template } from '../model/types';
+import type { FontDef } from '../fonts/catalog';
+interface EditorProps {
+    template: Template;
+    onBack: () => void;
+    /** Tras «Guardar como»: el template creado y las capas actuales (con sus data URL) para seguir editando. */
+    onSaved?: (template: Template, layers: Layer[]) => void;
+    /** Sube una fuente propia y la devuelve registrada (S4.16); sin ella no se ofrece «Subir fuente». */
+    uploadFont?: (file: File) => Promise<FontDef | null>;
+}
+/** Capa de imagen centrada, a lo más 40% del ancho de la pieza. */
+export declare const imageLayerFor: (image: {
+    src: string;
+    width: number;
+    height: number;
+}, template: Template, layers: Layer[], id: string) => ImageLayer;
+/** Editor de una plantilla: barra de herramientas y lienzo. El estado vive en `editorReducer`. */
+export declare const Editor: ({ template, onBack, onSaved, uploadFont }: EditorProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/EditorBar.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+/**
+ * Franja de las barras del editor (menús y herramientas): mismo fondo, espaciado y borde inferior
+ * para que se lean como un solo encabezado a todo lo ancho.
+ */
+export declare const EditorBar: ({ label, children }: {
+    label: string;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/features/templates/editor/EditorMenuBar.d.ts

@@ -0,0 +1,58 @@
+import type { ExportFormat } from '../export/render';
+import type { ViewOptions } from './Precision';
+type Keys = {
+    key: string;
+    mod?: boolean;
+    shift?: boolean;
+};
+/** «⇧⌘Z» en macOS, «Ctrl+Shift+Z» en los demás (diseño S4.9, D5). */
+export declare const shortcutLabel: ({ key, mod, shift }: Keys, isMac: boolean) => string;
+export declare const detectMac: () => boolean;
+export interface MenuBarActions {
+    back: () => void;
+    save: () => void;
+    saveAs: () => void;
+    exportAs: (format: ExportFormat) => void;
+    saveToLibrary: () => void;
+    reset: () => void;
+    undo: () => void;
+    redo: () => void;
+    duplicate: () => void;
+    remove: () => void;
+    toggleLock: () => void;
+    reorder: (to: 'front' | 'back' | 'up' | 'down') => void;
+    toggleView: (key: keyof ViewOptions) => void;
+    togglePanel: (side: 'left' | 'right') => void;
+    fit: () => void;
+    zoom100: () => void;
+    fullscreen: () => void;
+}
+interface EditorMenuBarProps {
+    name: string;
+    onRename: (name: string) => void;
+    width: number;
+    height: number;
+    dirty: boolean;
+    own: boolean;
+    saving: boolean;
+    exporting: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    selection: {
+        locked: boolean;
+    } | null;
+    view: ViewOptions;
+    panels: {
+        left: boolean;
+        right: boolean;
+    };
+    isMac: boolean;
+    actions: MenuBarActions;
+}
+/**
+ * Barra de menús del editor (diseño S4.9, D1–D5): título y medidas, «Sin guardar», menús Archivo,
+ * Edición y Vista con el `Menu` compuesto del DS (etiquetas, separadores, submenú de exportación y
+ * atajos como `endIcon`) y la acción principal a la derecha.
+ */
+export declare const EditorMenuBar: (p: EditorMenuBarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/EditorToolbar.d.ts

@@ -0,0 +1,20 @@
+interface EditorToolbarProps {
+    canUndo: boolean;
+    canRedo: boolean;
+    panels: {
+        left: boolean;
+        right: boolean;
+    };
+    scale: number;
+    isFit: boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+    onTogglePanel: (side: 'left' | 'right') => void;
+    onFullscreen: () => void;
+    onZoomBy: (delta: number) => void;
+    onZoomTo: (scale: number) => void;
+    onFit: () => void;
+}
+/** Barra de herramientas (diseño S4.9, D6): grupos de `IconButton` con tooltip y controles de zoom. */
+export declare const EditorToolbar: (p: EditorToolbarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/ElementPalette.d.ts

@@ -0,0 +1,10 @@
+import type { ElementPreset } from '../model/presets';
+interface ElementPaletteProps {
+    onAdd: (preset: ElementPreset) => void;
+    onUploadImage: (file: File) => void;
+    /** Abre el selector de la biblioteca; reemplaza al campo de URL (S4.13). */
+    onPickFromLibrary: () => void;
+}
+/** Elementos que se pueden agregar a la pieza (snowflake: rejilla de mosaicos). */
+export declare const ElementPalette: ({ onAdd, onUploadImage, onPickFromLibrary }: ElementPaletteProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/FloatingPanel.d.ts

@@ -0,0 +1,17 @@
+import type { ReactNode } from 'react';
+export declare const PANEL_GAP = 12;
+export declare const STRIP = 36;
+interface FloatingPanelProps {
+    side: 'left' | 'right';
+    title: string;
+    width: number;
+    open: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+}
+/**
+ * Panel flotante sobre el escenario (diseño S4.9, D7). Snowflake: el DS no tiene paneles laterales
+ * colapsables. Oculto deja una tira vertical para volver a abrirlo.
+ */
+export declare const FloatingPanel: ({ side, title, width, open, onToggle, children }: FloatingPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/FullscreenView.d.ts

@@ -0,0 +1,11 @@
+import type { Layer, Template } from '../model/types';
+/**
+ * Pantalla completa (diseño S4.5, D9): solo la pieza sobre fondo oscuro. Pide el modo nativo del
+ * navegador si existe; si lo niega, la vista funciona igual como capa fija. Esc, clic fuera o salir
+ * del modo nativo la cierran.
+ */
+export declare const FullscreenView: ({ template, layers, onClose }: {
+    template: Template;
+    layers: Layer[];
+    onClose: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/features/templates/editor/IconPicker.d.ts

@@ -0,0 +1,9 @@
+interface IconPickerProps {
+    open: boolean;
+    value: string;
+    onClose: () => void;
+    onPick: (icon: string) => void;
+}
+/** Selector de íconos de contenido (rejilla dentro de un Modal del DS). */
+export declare const IconPicker: ({ open, value, onClose, onPick }: IconPickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/Inspector.d.ts

@@ -0,0 +1,17 @@
+import type { Layer, LayerPatch } from '../model/types';
+interface InspectorProps {
+    layer: Layer;
+    onUpdate: (patch: LayerPatch) => void;
+    onRemove: () => void;
+    onDuplicate: () => void;
+    onReorder: (to: 'front' | 'back' | 'up' | 'down') => void;
+    onToggleBackground: () => void;
+    /** Cambiar la imagen de la capa sin moverla (S4.13). */
+    onReplaceFile: (file: File) => void;
+    onReplaceFromLibrary: () => void;
+    /** Subir una fuente propia desde el selector de tipografía (S4.16). */
+    onUploadFont?: () => void;
+}
+/** Propiedades de la capa seleccionada, según su tipo. */
+export declare const Inspector: ({ layer: l, onUpdate, onRemove, onDuplicate, onReorder, onToggleBackground, onReplaceFile, onReplaceFromLibrary, onUploadFont }: InspectorProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/LayersPanel.d.ts

@@ -0,0 +1,12 @@
+import type { Layer, LayerPatch } from '../model/types';
+interface LayersPanelProps {
+    layers: Layer[];
+    selectedId: string | null;
+    onSelect: (id: string) => void;
+    onUpdate: (id: string, patch: LayerPatch) => void;
+    onRemove: (id: string) => void;
+    onMoveTo: (id: string, targetId: string, place: 'above' | 'below') => void;
+}
+/** Panel de capas con la del frente arriba; filas con arrastre para reordenar (snowflake). */
+export declare const LayersPanel: ({ layers, selectedId, onSelect, onUpdate, onRemove, onMoveTo }: LayersPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/Precision.d.ts

@@ -0,0 +1,23 @@
+import type { Layer } from '../model/types';
+export interface ViewOptions {
+    grid: boolean;
+    safe: boolean;
+    rulers: boolean;
+    snap: boolean;
+    guides: boolean;
+}
+/** Valores del prototipo: reglas y guías activas; el resto apagado. */
+export declare const DEFAULT_VIEW: ViewOptions;
+interface SafeAreaPanelProps {
+    show: boolean;
+    margin: number;
+    original: number;
+    max: number;
+    violations: Layer[];
+    onShow: (show: boolean) => void;
+    onMargin: (value: number) => void;
+    onSelect: (id: string) => void;
+}
+/** Área segura: mostrar, ajustar el margen, restablecer y ver qué capas salen (diseño S4.5, D8). */
+export declare const SafeAreaPanel: ({ show, margin, original, max, violations, onShow, onMargin, onSelect }: SafeAreaPanelProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/RangeField.d.ts

@@ -0,0 +1,12 @@
+interface RangeFieldProps {
+    label: string;
+    value: number;
+    min: number;
+    max: number;
+    step?: number;
+    onChange: (value: number) => void;
+    format?: (value: number) => string;
+}
+/** Control deslizante (snowflake: el DS no tiene *range*). */
+export declare const RangeField: ({ label, value, min, max, step, onChange, format }: RangeFieldProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/SaveTemplateDialog.d.ts

@@ -0,0 +1,14 @@
+interface SaveTemplateDialogProps {
+    open: boolean;
+    defaultName: string;
+    defaultFolder: string;
+    folders: string[];
+    onClose: () => void;
+    onSave: (target: {
+        name: string;
+        folder: string;
+    }) => void | Promise<void>;
+}
+/** «Guardar como template…»: nombre, carpeta y, opcional, una carpeta nueva dentro (diseño S4.6, D11). */
+export declare const SaveTemplateDialog: ({ open, defaultName, defaultFolder, folders, onClose, onSave }: SaveTemplateDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/Stage.d.ts

@@ -0,0 +1,29 @@
+import type { Layer, LayerPatch, Template } from '../model/types';
+interface StageProps {
+    template: Template;
+    layers: Layer[];
+    selectedId: string | null;
+    /** Escala de presentación del lienzo. */
+    scale: number;
+    onSelect: (id: string | null) => void;
+    /** `transient` = parte de un gesto en curso; el gesto termina con `onCommit`. */
+    onChange: (id: string, patch: LayerPatch, transient: boolean) => void;
+    onCommit: () => void;
+    /** Ajuste al arrastrar: unidad de cuadrícula (o `null`) y guías inteligentes (diseño S4.5, D2). */
+    precision?: {
+        grid: number | null;
+        guides: boolean;
+    };
+    overlays?: {
+        grid?: boolean;
+        safe?: boolean;
+        rulers?: boolean;
+    };
+}
+/**
+ * Lienzo interactivo (snowflake: el DS no tiene un escenario de edición). Pinta la pieza con el
+ * mismo `LayerCanvas` de la exportación y encima una capa de cajas para seleccionar, mover y
+ * redimensionar. Un arrastre emite cambios transitorios y termina en un solo `onCommit`.
+ */
+export declare const Stage: ({ template, layers, selectedId, scale, onSelect, onChange, onCommit, precision, overlays }: StageProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/TemplateFolderSelect.d.ts

@@ -0,0 +1,9 @@
+interface TemplateFolderSelectProps {
+    folders: string[];
+    value: string;
+    onChange: (path: string) => void;
+    label?: string;
+}
+/** Carpetas de «Mis templates» (rutas) con sangría por nivel; `''` es la raíz. */
+export declare const TemplateFolderSelect: ({ folders, value, onChange, label }: TemplateFolderSelectProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/TemplatePicker.d.ts

@@ -0,0 +1,23 @@
+import type { Template } from '../model/types';
+interface TemplatePickerProps {
+    bases: Template[];
+    mine: Template[];
+    folders: string[];
+    onOpen: (template: Template) => void;
+    onCreateBlank: (width: number, height: number) => void;
+    onRename: (template: Template, name: string) => void;
+    onDuplicate: (template: Template) => void;
+    onMove: (template: Template, folder: string) => void;
+    onDelete: (template: Template) => void;
+    onCreateFolder: (parent: string, name: string) => void;
+    onRenameFolder: (path: string, name: string) => void;
+    onDeleteFolder: (path: string) => void;
+    /** Vuelve una base editada a la versión de InterWare (S4.15). */
+    onRestoreBase: (template: Template) => void;
+}
+/**
+ * Selector de plantillas (diseño S4.6, D10): lienzo en blanco con tamaños predefinidos, «Mis
+ * templates» por carpetas y las plantillas base. Presentacional: las operaciones llegan por props.
+ */
+export declare const TemplatePicker: (p: TemplatePickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/TemplatesTab.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pestaña Plantillas: selector (lienzo en blanco, «Mis templates», bases) o el editor abierto. Un
+ * template propio se abre con sus imágenes convertidas a data URL (diseño S4.6, D7).
+ */
+export declare const TemplatesTab: () => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/features/templates/editor/TypographyControls.d.ts

@@ -0,0 +1,24 @@
+import type { LayerPatch } from '../model/types';
+type Align = 'left' | 'center' | 'right';
+interface TypographyLayer {
+    font?: string;
+    fontSize: number;
+    fontWeight: number;
+    fontStyle?: 'normal' | 'italic';
+    textAlign?: Align;
+}
+interface TypographyControlsProps {
+    layer: TypographyLayer;
+    /** Solo las capas de texto se alinean; lista, cita y etiqueta no. */
+    alignable: boolean;
+    onUpdate: (patch: LayerPatch) => void;
+    /** Subir una fuente propia (S4.16, D4). */
+    onUploadFont?: () => void;
+}
+/**
+ * Controles de texto como los de los editores habituales (S4.16, D6): tipografía con vista previa,
+ * peso según la fuente, tamaño con − / campo / + sobre la escala estándar, negritas y cursivas como
+ * toggles y alineación con íconos.
+ */
+export declare const TypographyControls: ({ layer: l, alignable, onUpdate, onUploadFont }: TypographyControlsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/templates/editor/icons.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentType, SVGProps } from 'react';
+import type { LayerType } from '../model/types';
+type IconComponent = ComponentType<SVGProps<SVGSVGElement>>;
+/** Íconos de interfaz del editor (paleta de elementos y panel de capas). */
+export declare const UI_ICONS: Record<string, IconComponent>;
+export declare const LAYER_ICONS: Record<LayerType, IconComponent>;
+export {};

package/dist/admin/src/features/templates/editor/overlays.d.ts

@@ -0,0 +1,20 @@
+export declare const GridOverlay: ({ w, h, unit, scale }: {
+    w: number;
+    h: number;
+    unit: number;
+    scale: number;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const SafeAreaOverlay: ({ w, h, margin, scale }: {
+    w: number;
+    h: number;
+    margin: number;
+    scale: number;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const RULER = 24;
+/** Reglas superior e izquierda con marcas cada `unit` px del lienzo y media marca intermedia. */
+export declare const Rulers: ({ w, h, scale, unit }: {
+    w: number;
+    h: number;
+    scale: number;
+    unit?: number;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/features/templates/editor/useCanvasNav.d.ts

@@ -0,0 +1,25 @@
+import type { MouseEvent as ReactMouseEvent, RefObject } from 'react';
+import type { View } from '../model/viewport';
+/**
+ * Navegación del lienzo (diseño S4.9, D8–D11). «Ajustar» calcula la vista con el espacio libre
+ * entre paneles; cualquier paneo o zoom pasa a una vista manual.
+ * - Rueda nativa `{ passive: false }`: con Ctrl/⌘ (el pellizco del trackpad llega así) hace zoom
+ *   hacia el cursor; sin modificador desplaza (dos dedos).
+ * - Arrastre del fondo, Espacio + arrastrar y botón central desplazan.
+ */
+export declare const useCanvasNav: (viewport: RefObject<HTMLElement>, piece: {
+    w: number;
+    h: number;
+}, insets: {
+    left: number;
+    right: number;
+}, rulers: number) => {
+    view: View;
+    isFit: boolean;
+    spaceDown: boolean;
+    panning: boolean;
+    startPan: (e: ReactMouseEvent) => void;
+    fit: () => void;
+    zoomTo: (scale: number) => void;
+    zoomBy: (delta: number) => void;
+};

package/dist/admin/src/features/templates/editor/useFitScale.d.ts

@@ -0,0 +1,3 @@
+import type { RefObject } from 'react';
+/** Escala que hace caber la pieza en el contenedor (nunca mayor que 100%). */
+export declare const useFitScale: (ref: RefObject<HTMLElement>, width: number, height: number) => number;

package/dist/admin/src/features/templates/export/fontEmbed.d.ts

@@ -0,0 +1,22 @@
+import type { FontDef } from '../fonts/catalog';
+import type { Layer } from '../model/types';
+type WithLayers = {
+    layers?: Layer[];
+};
+type Fetcher = (url: string) => Promise<Blob>;
+/**
+ * Fuentes que usa una pieza (S4.16, D5): las de sus capas con texto, Inter (la base del lienzo) y
+ * Texta si lleva el logo (su palabra va en Texta).
+ */
+export declare const usedFonts: (template: WithLayers) => FontDef[];
+/**
+ * `@font-face` de las fuentes dadas con cada archivo incrustado como data URL. Se pasa a
+ * html-to-image como `fontEmbedCSS` para que no recorra las hojas de estilo del panel: al hacerlo
+ * intenta descargar fuentes de otros dominios (Font Awesome), la CSP del admin lo bloquea y la
+ * exportación se queda colgada. Una fuente que no se pueda descargar se omite (la pieza cae a la
+ * fuente de respaldo); las subidas ya vienen como data URL.
+ */
+export declare const buildFontEmbedCss: (fonts: FontDef[], fetcher?: Fetcher) => Promise<string>;
+/** `@font-face` incrustado de las fuentes de la pieza; cada fuente se descarga una vez por sesión. */
+export declare const getFontEmbedCss: (template: WithLayers) => Promise<string>;
+export {};

package/dist/admin/src/features/templates/export/imageSource.d.ts

@@ -0,0 +1,21 @@
+type Post = (url: string, body: {
+    url: string;
+}) => Promise<{
+    data: {
+        base64: string;
+        contentType: string;
+    };
+}>;
+export declare const DOWNLOAD_PROXY = "/strapi-content-generator-gemini/download-file";
+/**
+ * Convierte una imagen en data URL para que pueda entrar al lienzo y exportarse. El bucket S3 no
+ * tiene CORS para el panel: sin esto el lienzo queda contaminado y la exportación falla (diseño
+ * S4.4, D4). Las imágenes remotas pasan por el proxy autenticado del plugin.
+ */
+export declare const toDataUrl: (src: string, post: Post, origin?: string) => Promise<string>;
+/** Mide una imagen a partir de su URL (se usa con data URLs). */
+export declare const measureImage: (src: string) => Promise<{
+    width: number;
+    height: number;
+}>;
+export {};

package/dist/admin/src/features/templates/export/pdf.d.ts

@@ -0,0 +1,6 @@
+/**
+ * PDF 1.4 de una página con un JPEG a página completa (diseño S4.7, D3). La página mide lo mismo
+ * que la pieza a 96 ppp (px × 0.75 = pt). El JPEG se incrusta tal cual con `DCTDecode`: no se
+ * decodifica ni se recomprime.
+ */
+export declare const buildPdf: (jpeg: Uint8Array, width: number, height: number) => Uint8Array;

package/dist/admin/src/features/templates/export/render.d.ts

@@ -0,0 +1,22 @@
+import type { Layer } from '../model/types';
+export type ExportFormat = 'png' | 'jpg' | 'svg' | 'pdf';
+export declare const FORMAT_LABELS: Record<ExportFormat, string>;
+/** «Story / Reels», 'png' → «story-reels.png». */
+export declare const fileNameFor: (name: string, ext: ExportFormat) => string;
+/** Color de relleno del JPEG: el de la plantilla si es sólido; con degradado, blanco. */
+export declare const jpegBackground: (background: string) => string;
+/**
+ * Renderiza la pieza (el nodo `data-export-root`) a su tamaño real en el formato pedido. Quita la
+ * escala de presentación del lienzo, espera a las fuentes de marca y las incrusta sin recorrer las
+ * hojas de estilo del panel (ver `fontEmbed.ts`). El PDF se arma con el JPEG (diseño S4.7, D3).
+ */
+export declare const renderPiece: (node: HTMLElement, tpl: {
+    width: number;
+    height: number;
+    background: string;
+    layers?: Layer[];
+}, format: ExportFormat, { timeoutMs }?: {
+    timeoutMs?: number;
+}) => Promise<Blob>;
+/** Descarga un blob con el nombre dado. */
+export declare const downloadBlob: (blob: Blob, name: string) => void;

package/dist/admin/src/features/templates/export/useEditorIO.d.ts

@@ -0,0 +1,18 @@
+import type { ExportFormat } from './render';
+import type { Template } from '../model/types';
+/**
+ * Entrada y salida del editor que dependen del panel de Strapi (cliente autenticado, biblioteca y
+ * notificaciones). Aislado en un hook para que el editor se pueda probar sin el panel.
+ */
+export declare const useEditorIO: () => {
+    loadImage: (url: string) => Promise<{
+        width: number;
+        height: number;
+        src: string;
+    } | null>;
+    exportAs: (node: HTMLElement | null, template: Template, format: ExportFormat) => Promise<void>;
+    saveToLibrary: (node: HTMLElement | null, template: Template, { name, folderId }: {
+        name: string;
+        folderId: number | null;
+    }) => Promise<boolean>;
+};

package/dist/admin/src/features/templates/fonts/catalog.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Catálogo de tipografías del editor (S4.16, D1). Los archivos los sirve el CMS desde
+ * `public/fonts/` (mismo origen que el panel, D2): Texta es comercial y no viaja en el paquete npm.
+ * Agregar una fuente = copiar sus archivos al CMS y añadir una entrada aquí. Las fuentes que sube el
+ * equipo se registran en tiempo de ejecución con `registerCustomFonts` (D4).
+ */
+export interface FontFile {
+    url: string;
+    /** Uno («400») o un rango de fuente variable («100 900»). */
+    weight: string;
+    style: 'normal' | 'italic';
+    format: 'truetype' | 'opentype' | 'woff' | 'woff2';
+}
+export interface FontDef {
+    id: string;
+    label: string;
+    /** Nombre CSS de la familia. */
+    family: string;
+    /** Respaldo del mismo tipo (sans, serif o monoespaciada) si el archivo no carga. */
+    fallback: string;
+    weights: number[];
+    /** Tiene cursivas propias; sin ellas el navegador las inclina. */
+    italic: boolean;
+    files: FontFile[];
+    /** Subida por el equipo a «/Fuentes». */
+    custom?: boolean;
+}
+export declare const BUILTIN_FONTS: FontDef[];
+export declare const DEFAULT_FONT = "inter";
+/** Reemplaza las fuentes subidas por el equipo (se llama al cargar la biblioteca de fuentes). */
+export declare const registerCustomFonts: (fonts: FontDef[]) => void;
+/** Para `useSyncExternalStore`: el lienzo se vuelve a pintar cuando cargan las fuentes subidas. */
+export declare const subscribeFonts: (listener: () => void) => () => boolean;
+export declare const fontsVersion: () => number;
+export declare const allFonts: () => FontDef[];
+/** La fuente de una capa; lo desconocido (p. ej. una fuente subida que se borró) cae a Inter. */
+export declare const resolveFont: (id: string | undefined) => FontDef;
+export declare const fontStack: (f: FontDef) => string;
+/** El peso disponible más cercano (una fuente sin 800 usa su 700). */
+export declare const nearestWeight: (f: FontDef, weight: number) => number;
+export declare const WEIGHT_LABELS: Record<number, string>;
+/** `@font-face` de las fuentes dadas; `url` puede ser una ruta del CMS o una data URL. */
+export declare const fontFaceCss: (fonts: FontDef[]) => string;
+/** Escala de tamaños de los editores de texto habituales (D6). */
+export declare const FONT_SIZES: number[];
+/** Tamaño estándar siguiente (`+1`) o anterior (`-1`); un valor libre salta al estándar más próximo. */
+export declare const stepSize: (size: number, dir: 1 | -1) => number;

package/dist/admin/src/features/templates/fonts/customFonts.d.ts

@@ -0,0 +1,19 @@
+import type { FontDef } from './catalog';
+/**
+ * Fuentes que sube el equipo (S4.16, D4). Viven en la carpeta «Fuentes» de la biblioteca del Estudio
+ * («/Fuentes»); cada archivo es una fuente. La licencia de cada una es responsabilidad de quien la sube.
+ */
+export declare const FONTS_FOLDER = "Fuentes";
+export declare const FONT_MAX_BYTES: number;
+export declare const isFontName: (name: string) => boolean;
+/** Error para mostrar, o `null` si el archivo se puede subir. */
+export declare const checkFontFile: (file: File) => string | null;
+/**
+ * Archivo de la biblioteca → fuente del catálogo. El nombre visible sale del archivo
+ * («Montserrat-SemiBold.ttf» → «Montserrat SemiBold»); la familia CSS es única por archivo para no
+ * chocar con fuentes del sistema. Un archivo trae un solo peso: las negritas las simula el navegador.
+ */
+export declare const fontFromFile: (file: {
+    id: number;
+    name: string;
+}, dataUrl: string) => FontDef;

package/dist/admin/src/features/templates/fonts/useCustomFonts.d.ts

@@ -0,0 +1,9 @@
+import type { FontDef } from './catalog';
+/**
+ * Fuentes propias del equipo (S4.16, D4): al montar carga las de «/Fuentes» al catálogo (por el
+ * proxy, como data URL: mismo origen para el lienzo y la exportación) y permite subir otra.
+ */
+export declare const useCustomFonts: () => {
+    upload: (file: File) => Promise<FontDef | null>;
+    reload: () => Promise<void>;
+};

package/dist/admin/src/features/templates/fonts/useFonts.d.ts

@@ -0,0 +1,2 @@
+/** Catálogo completo (del código y subidas); re-renderiza cuando cambian las subidas (S4.16). */
+export declare const useFonts: () => import("./catalog").FontDef[];