@interware/content-generator 0.4.4 → 0.6.0

package/dist/admin/src/features/image-studio/ImageStudioTabs.d.ts

@@ -0,0 +1,26 @@
+export declare const STUDIO_TABS: readonly [{
+    readonly value: "generator";
+    readonly label: "Generador";
+}, {
+    readonly value: "templates";
+    readonly label: "Plantillas";
+}, {
+    readonly value: "library";
+    readonly label: "Imágenes y documentos";
+}];
+export type StudioTab = (typeof STUDIO_TABS)[number]['value'];
+/**
+ * Rutas anteriores del módulo de imágenes. Redirigen a su pestaña equivalente para no romper
+ * enlaces guardados (diseño del epic, Migration Path).
+ */
+export declare const LEGACY_ROUTES: {
+    path: string;
+    tab: StudioTab;
+}[];
+export declare const legacyRedirect: (tab: StudioTab) => import("react/jsx-runtime").JSX.Element;
+/** `/plugins/<id>/image-studio` (S4.4–S4.9) → la entrada propia del menú, conservando `?tab=` (S4.10). */
+export declare const StudioRedirect: () => import("react/jsx-runtime").JSX.Element;
+/**
+ * Pestañas del Estudio de imágenes. La pestaña activa vive en `?tab=` para que se pueda enlazar.
+ */
+export declare const ImageStudioTabs: () => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/features/image-studio/SegmentedSwitch.d.ts

@@ -0,0 +1,18 @@
+import type { ComponentType, SVGProps } from 'react';
+export interface SegmentedOption<T extends string> {
+    value: T;
+    label: string;
+    Icon: ComponentType<SVGProps<SVGSVGElement>>;
+}
+interface SegmentedSwitchProps<T extends string> {
+    label: string;
+    options: readonly SegmentedOption<T>[];
+    value: T;
+    onChange: (value: T) => void;
+}
+/**
+ * Control segmentado del Estudio (S4.13, generalizado en S4.18): modos del Generador y de «Quitar fondo».
+ * Snowflake: el DS 2.2 no tiene un control segmentado; es un `radiogroup` con los tokens del DS.
+ */
+export declare const SegmentedSwitch: <T extends string>({ label, options, value, onChange }: SegmentedSwitchProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/image-studio/checkerboard.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cuadrícula de transparencia (fondo CSS): deja ver qué partes no tienen fondo. Siempre clara, como en
+ * los editores habituales: en el tema oscuro, una cuadrícula oscura esconde el texto y los logos azul marino.
+ */
+export declare const CHECKERBOARD = "repeating-conic-gradient(#e6e6ec 0% 25%, #ffffff 0% 50%) 50% / 16px 16px";

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

@@ -0,0 +1,17 @@
+import type { LibraryFile } from './uploadApi';
+export type FileAction = 'preview' | 'download' | 'rename' | 'replace' | 'move' | 'removeBackground' | 'delete';
+/** Quitar fondo aplica a mapas de bits: un SVG puede no declarar tamaño y es vectorial. */
+export declare const canRemoveBackground: (f: LibraryFile) => boolean;
+/** Piezas que el plugin generó con IA: el servidor les pone ese caption al subirlas. */
+export declare const isGenerated: (f: LibraryFile) => boolean;
+/** Tamaño en KB (Strapi guarda `size` en KB). */
+export declare const formatSize: (kb?: number) => string;
+interface FileCardProps {
+    file: LibraryFile;
+    onAction: (action: FileAction, file: LibraryFile) => void;
+    /** Avance de «Quitar fondo» sobre este archivo, si está en curso. */
+    busy?: string;
+}
+/** Tarjeta de archivo arrastrable a una carpeta del árbol. */
+export declare const FileCard: ({ file, onAction, busy }: FileCardProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,14 @@
+import type { FolderCounts } from './uploadApi';
+import type { FolderNode } from './model';
+export declare const FILE_DRAG_TYPE = "application/x-iw-library-file";
+interface FolderTreeProps {
+    tree: FolderNode[];
+    counts: FolderCounts;
+    current: number | null;
+    onOpen: (id: number | null) => void;
+    /** Soltar un archivo de la grilla sobre una carpeta lo mueve ahí. */
+    onDropFile: (fileId: number, folderId: number | null) => void;
+}
+/** Árbol de carpetas con arrastrar y soltar (snowflake: el DS no tiene árbol). */
+export declare const FolderTree: ({ tree, counts, current, onOpen, onDropFile }: FolderTreeProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,46 @@
+/// <reference types="react" />
+import type { FolderNode } from './model';
+interface NameDialogProps {
+    open: boolean;
+    title: string;
+    label: string;
+    initial?: string;
+    confirmLabel: string;
+    /** Devuelve un mensaje de error para mostrar, o `null` si el nombre es válido. */
+    validate?: (name: string) => string | null;
+    onClose: () => void;
+    onConfirm: (name: string) => void | Promise<void>;
+}
+/** Pide un nombre (carpeta nueva, renombrar carpeta o archivo). */
+export declare const NameDialog: ({ open, title, label, initial, confirmLabel, validate, onClose, onConfirm }: NameDialogProps) => import("react/jsx-runtime").JSX.Element;
+interface ConfirmDialogProps {
+    open: boolean;
+    title: string;
+    children: React.ReactNode;
+    confirmLabel?: string;
+    onClose: () => void;
+    onConfirm: () => void | Promise<void>;
+}
+/** Confirmación de una acción destructiva (DS `Dialog`). */
+export declare const ConfirmDialog: ({ open, title, children, confirmLabel, onClose, onConfirm }: ConfirmDialogProps) => import("react/jsx-runtime").JSX.Element;
+interface FolderSelectProps {
+    tree: FolderNode[];
+    value: number | null;
+    onChange: (id: number | null) => void;
+    label?: string;
+}
+/** Selector de carpeta con sangría por nivel; la raíz («/») es «Generated». */
+export declare const FolderSelect: ({ tree, value, onChange, label }: FolderSelectProps) => import("react/jsx-runtime").JSX.Element;
+interface MoveDialogProps {
+    open: boolean;
+    tree: FolderNode[];
+    current: number | null;
+    onClose: () => void;
+    onConfirm: (destination: number | null) => void | Promise<void>;
+}
+/** Elegir la carpeta destino para mover un archivo. */
+export declare const MoveDialog: ({ open, tree, current, onClose, onConfirm }: MoveDialogProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EmptyNote: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,15 @@
+import type { LibraryFile } from './uploadApi';
+interface LibraryImagePickerProps {
+    open: boolean;
+    /** Cuántas se pueden elegir. Con 1, elegir otra reemplaza la anterior. */
+    max: number;
+    onClose: () => void;
+    onPick: (files: LibraryFile[]) => void;
+}
+/**
+ * Elegir imágenes de la biblioteca (S4.13, D2): navega las carpetas de «Generated» y muestra solo
+ * imágenes. Lo elegido se conserva al cambiar de carpeta. Snowflake: el DS no tiene un selector de
+ * archivos con miniaturas.
+ */
+export declare const LibraryImagePicker: ({ open, max, onClose, onPick }: LibraryImagePickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+/** Pestaña «Imágenes y documentos»: la Media Library de Strapi organizada por carpetas. */
+export declare const LibraryTab: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,15 @@
+interface SaveToLibraryDialogProps {
+    open: boolean;
+    defaultName: string;
+    onClose: () => void;
+    onSave: (target: {
+        name: string;
+        folderId: number | null;
+    }) => void | Promise<void>;
+}
+/**
+ * Diálogo «Guardar en la biblioteca»: nombre, carpeta y, si hace falta, una subcarpeta nueva. Lo
+ * usan el Generador (S4.2) y la exportación del editor (S4.7); la subida la hace quien lo abre.
+ */
+export declare const SaveToLibraryDialog: ({ open, defaultName, onClose, onSave }: SaveToLibraryDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,40 @@
+/** Carpeta de la Media Library tal como la devuelve `GET /upload/folder-structure`. */
+export interface FolderNode {
+    id: number;
+    name: string;
+    children: FolderNode[];
+}
+export interface FlatFolder {
+    id: number;
+    name: string;
+    parentId: number | null;
+    depth: number;
+}
+/** Carpetas en orden de árbol (padre antes que hijas) con su padre y profundidad. */
+export declare const flattenTree: (tree: FolderNode[], parentId?: number | null, depth?: number) => FlatFolder[];
+/** Ruta desde la raíz hasta la carpeta (vacía para la raíz o un id inexistente). */
+export declare const pathTo: (tree: FolderNode[], id: number | null) => FolderNode[];
+/** Subcarpetas de una carpeta, o las de la raíz con `null`. */
+export declare const childrenOf: (tree: FolderNode[], id: number | null) => FolderNode[];
+/** Nombre de carpeta limpio: sin espacios sobrantes ni diagonales (Strapi las usa en rutas). */
+export declare const cleanFolderName: (name: string) => string;
+/** ¿Ya existe una carpeta hermana con ese nombre? Sin distinguir mayúsculas ni espacios. */
+export declare const nameTaken: (tree: FolderNode[], parentId: number | null, name: string) => boolean;
+export interface DeletePlan {
+    move: {
+        destinationFolderId: number | null;
+        fileIds: number[];
+        folderIds: number[];
+    } | null;
+    remove: number[];
+}
+/**
+ * Plan para eliminar una carpeta sin perder archivos. En Strapi 5.51 borrar una carpeta borra sus
+ * archivos, así que primero se mueven archivos y subcarpetas a la carpeta superior (o a la raíz) y
+ * después se borra la carpeta, ya vacía (diseño S4.3, D1).
+ */
+export declare const safeDeletePlan: (tree: FolderNode[], folderId: number, fileIds: number[]) => DeletePlan | null;
+/** «retrato.jpg» → «retrato (sin fondo).png»: la copia sin fondo siempre es PNG con transparencia. */
+export declare const noBackgroundName: (name: string) => string;
+/** Los tipos de imagen que acepta Gemini; la biblioteca también guarda documentos (S4.13, D1). */
+export declare const IMAGE_MIMES: string[];

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

@@ -0,0 +1,11 @@
+import type { UploadApi } from './uploadApi';
+/** Carpeta de la Media Library que el Estudio usa como raíz (decisión de Israel, S4.11). */
+export declare const STUDIO_ROOT = "Generated";
+/** Cómo se muestra la raíz en el Estudio: es la raíz de su biblioteca, aunque sea «Generated» (S4.14). */
+export declare const ROOT_LABEL = "/";
+/**
+ * La API de la biblioteca con una carpeta como raíz: `getTree` devuelve sus subcarpetas y cada
+ * `null` («la raíz») se traduce a su id, así que nada se sube, crea ni mueve fuera de ella. La
+ * carpeta se busca (o se crea) una vez por instancia.
+ */
+export declare const scopeToFolder: (base: UploadApi, rootName: string) => UploadApi;

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

@@ -0,0 +1,77 @@
+import type { FolderNode } from './model';
+/** Subconjunto de `useFetchClient` de Strapi que usa la biblioteca (inyectado para probar). */
+export interface UploadClient {
+    get: (url: string, config?: {
+        params?: Record<string, unknown>;
+    }) => Promise<{
+        data: any;
+    }>;
+    post: (url: string, body?: unknown) => Promise<{
+        data: any;
+    }>;
+    put: (url: string, body?: unknown) => Promise<{
+        data: any;
+    }>;
+}
+export interface LibraryFile {
+    id: number;
+    documentId?: string;
+    name: string;
+    url?: string;
+    mime?: string;
+    ext?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+    caption?: string | null;
+    alternativeText?: string | null;
+    folder?: {
+        id: number;
+    } | null;
+    formats?: Record<string, {
+        url: string;
+    }> | null;
+    updatedAt?: string;
+}
+export type FolderCounts = Record<number, {
+    files: number;
+    children: number;
+}>;
+/**
+ * Cliente de la API de administración de upload de Strapi 5.51 (ADR-002). La biblioteca no tiene
+ * endpoints propios: los permisos y el cálculo de rutas de carpetas son los de la Media Library.
+ */
+export declare const createUploadApi: (client: UploadClient) => {
+    getTree(): Promise<FolderNode[]>;
+    getCounts(): Promise<FolderCounts>;
+    /** Archivos de una carpeta; con `mimes`, solo esos tipos (el selector de imágenes, S4.13). */
+    listFiles(folderId: number | null, { mimes }?: {
+        mimes?: string[];
+    }): Promise<LibraryFile[]>;
+    /** Las más recientes de varias carpetas a la vez («Recientes» del Generador, S4.14). */
+    listRecent({ folderIds, mimes, limit }: {
+        folderIds: number[];
+        mimes?: string[];
+        limit: number;
+    }): Promise<LibraryFile[]>;
+    createFolder(name: string, parent: number | null): Promise<FolderNode>;
+    renameFolder(id: number, name: string, parent: number | null): Promise<void>;
+    uploadFiles(files: File[], folderId: number | null): Promise<LibraryFile[]>;
+    renameFile(file: Pick<LibraryFile, 'id' | 'name' | 'folder' | 'alternativeText' | 'caption'>, name: string): Promise<void>;
+    replaceFile(id: number, file: File): Promise<void>;
+    move({ fileIds, folderIds }: {
+        fileIds?: number[];
+        folderIds?: number[];
+    }, destinationFolderId: number | null): Promise<void>;
+    remove({ fileIds, folderIds }: {
+        fileIds?: number[];
+        folderIds?: number[];
+    }): Promise<void>;
+    /** Elimina una carpeta dejando sus archivos y subcarpetas en la carpeta superior (D1). */
+    deleteFolderSafely: (tree: FolderNode[], folderId: number) => Promise<void>;
+};
+type FolderOps = Pick<ReturnType<typeof createUploadApi>, 'listFiles' | 'move' | 'remove'>;
+/** Plan de `safeDeletePlan` ejecutado con las operaciones dadas (las de la raíz del Estudio, S4.11). */
+export declare const deleteFolderSafely: (api: FolderOps, tree: FolderNode[], folderId: number) => Promise<void>;
+export type UploadApi = ReturnType<typeof createUploadApi>;
+export {};

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 {};