@interware/content-generator 0.4.4 → 0.5.0

package/dist/admin/src/features/background-removal/imageCanvas.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Canvas de «Quitar fondo» (S4.18): leer los píxeles de una imagen, pintarlos y exportarlos a PNG.
+ * Aislado aquí porque jsdom no dibuja; las pruebas lo simulan.
+ */
+export interface Pixels {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+}
+export declare const canvas: (width: number, height: number) => {
+    c: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+};
+export declare const loadImage: (src: string) => Promise<HTMLImageElement>;
+/** Píxeles RGBA de una imagen (data URL o URL del mismo origen) a su tamaño original. */
+export declare const loadPixels: (src: string) => Promise<Pixels>;
+/** Pinta los píxeles en un canvas de la página (la vista previa). */
+export declare const drawPixels: (target: HTMLCanvasElement, width: number, height: number, data: Uint8ClampedArray) => void;
+/** Píxeles → PNG en data URL (conserva la transparencia). */
+export declare const pixelsToDataUrl: (width: number, height: number, data: Uint8ClampedArray) => string;

package/dist/admin/src/features/background-removal/mask.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Posprocesamiento de «Quitar fondo» en el panel (S4.17). La normalización y el modelo (ISNet) los hace el
+ * worker (`static/background-worker.mjs`); aquí se aplica su máscara 0–1 al tamaño de la imagen.
+ * Funciones puras sobre arreglos RGBA: el canvas queda en `runtime.ts`.
+ */
+export declare const INPUT_SIZE = 1024;
+/** Máscara 0–1 → RGBA en gris opaco, para escalarla con un canvas sin alfa premultiplicado. */
+export declare const maskToRgba: (mask: Float32Array, width: number, height: number) => Uint8ClampedArray;
+/** Usa el canal rojo de la máscara (ya al tamaño de la imagen) como alfa de la imagen. */
+export declare const applyAlpha: (rgba: Uint8ClampedArray, maskRgba: Uint8ClampedArray) => void;

package/dist/admin/src/features/background-removal/runtime.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Worker que sirve el CMS desde `/ort/` (lo copia `npm run assets:image-studio` de web-cms desde
+ * `static/background-worker.mjs`): la inferencia corre fuera del hilo del panel (S4.17, ADR-007).
+ */
+export declare const WORKER_URL = "/ort/background-worker.mjs";
+/** Límite por imagen: con WASM en una máquina lenta tarda decenas de segundos, nunca minutos. */
+export declare const RUN_TIMEOUT_MS = 120000;
+export declare const TIMEOUT_MESSAGE = "Quitar fondo tard\u00F3 demasiado. Intenta de nuevo.";
+export declare class RemoveBackgroundTimeout extends Error {
+    constructor();
+}
+/** Mensaje para el panel: el aviso de tiempo agotado o el genérico. */
+export declare const removeBackgroundError: (err: unknown) => "Quitar fondo tardó demasiado. Intenta de nuevo." | "No se pudo quitar el fondo.";
+export interface Model {
+    /** Píxeles RGBA de 1024 × 1024 → máscara 0–1. El búfer se transfiere al worker. */
+    run: (rgba: Uint8ClampedArray) => Promise<Float32Array>;
+}
+/**
+ * Crea el worker y carga el modelo una sola vez por sesión del panel. El worker elige WebGPU o WASM.
+ * Si la carga o una imagen fallan, o una imagen pasa del límite, termina el worker y descarta la
+ * promesa: una sesión que falló puede no volver a responder, y el siguiente intento empieza de cero.
+ */
+export declare const loadModel: (onStatus?: (status: string) => void) => Promise<Model>;
+/** Solo para pruebas. */
+export declare const resetModel: () => void;
+/**
+ * Quita el fondo de una imagen (data URL o URL del mismo origen) y devuelve un PNG en data URL con
+ * el fondo transparente, al tamaño original. La máscara vuelve a ese tamaño escalándola con el
+ * canvas (diseño S4.7, D8).
+ */
+export declare const removeBackground: (src: string, onStatus?: (status: string) => void) => Promise<string>;

package/dist/admin/src/features/generator/EditEmpty.d.ts

@@ -0,0 +1,13 @@
+import type { LibraryFile } from '../library/uploadApi';
+interface EditEmptyProps {
+    disabled: boolean;
+    onUpload: (file: File | undefined) => void;
+    onOpenLibrary: () => void;
+    onOpenRecent: (file: LibraryFile) => void;
+}
+/**
+ * Modo Editar sin imagen (S4.13): arrastrar, subir o elegir de la biblioteca, con las imágenes más
+ * recientes de toda la biblioteca (raíz y subcarpetas, S4.14) a un clic.
+ */
+export declare const EditEmpty: ({ disabled, onUpload, onOpenLibrary, onOpenRecent }: EditEmptyProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/generator/GeneratorTab.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Pestaña «Generador» del Estudio de imágenes (diseño S4.2, modos de S4.13). «Crear imagen»: parámetros,
+ * referencias de estilo y prompt con «Expandir idea». «Editar imagen»: una imagen (generada, subida o
+ * de la biblioteca) con cambios por instrucción, elementos para integrar e historial de versiones en
+ * memoria. Nada se sube a la biblioteca hasta que se guarda (D4).
+ */
+export declare const GeneratorTab: () => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/features/generator/GroundingSources.d.ts

@@ -0,0 +1,9 @@
+import type { Grounding } from './generatorApi';
+/**
+ * Fuentes y sugerencia de búsqueda de una imagen generada con búsqueda de Google (S4.14, D6). Los
+ * términos de Google piden mostrar la sugerencia tal cual: es HTML de Google, así que va en un
+ * iframe `srcdoc` sin scripts (solo puede abrir sus enlaces en otra pestaña).
+ */
+export declare const GroundingSources: ({ grounding }: {
+    grounding: Grounding;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/dist/admin/src/features/generator/ModeSwitch.d.ts

@@ -0,0 +1,6 @@
+export type GeneratorMode = 'create' | 'edit';
+/** Crear o editar (S4.13): dos modos separados para que quede claro qué aplica en cada uno. */
+export declare const ModeSwitch: ({ value, onChange }: {
+    value: GeneratorMode;
+    onChange: (mode: GeneratorMode) => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/features/generator/PromptComposer.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import type { PromptLabels } from '../../lib/promptRules';
+interface PromptComposerProps {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    /** Recibe el texto ya saneado (S4.14, D1). */
+    onSubmit: (text: string) => void;
+    labels: PromptLabels;
+    placeholder: string;
+    actionLabel: string;
+    actionIcon: ReactNode;
+    loading: boolean;
+    disabled: boolean;
+    hint?: string;
+    /** Acciones secundarias dentro del campo, a la izquierda del contador (p. ej. «Expandir idea»). */
+    tools?: ReactNode;
+}
+/**
+ * Campo de prompt con la acción principal dentro (S4.14, D3): contador, validación con las reglas
+ * compartidas y ⌘/Ctrl + Enter. Snowflake: el `Textarea` del DS no admite contenido dentro del
+ * borde; se pinta con los tokens del tema.
+ */
+export declare const PromptComposer: (p: PromptComposerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/generator/ReferencePicker.d.ts

@@ -0,0 +1,26 @@
+interface ReferencePickerProps {
+    files: File[];
+    max: number;
+    modelLabel: string;
+    onChange: (files: File[]) => void;
+    /** Abre el selector de la biblioteca (S4.13). */
+    onPickFromLibrary: () => void;
+    /**
+     * Textos del uso: referencias de estilo al crear o elementos para el cambio al editar (S4.13).
+     * `noun` arma «Agregar …», «… desde la biblioteca» y las etiquetas accesibles.
+     */
+    label?: string;
+    hint?: string;
+    noun?: {
+        plural: string;
+        capital: string;
+        file: string;
+        none: string;
+    };
+}
+/**
+ * Imágenes de referencia con miniaturas. Snowflake: el DS no tiene un cargador de imágenes con
+ * vista previa. El tope lo da el modelo (diseño S4.2, D7); con 0 se deshabilita y lo explica.
+ */
+export declare const ReferencePicker: ({ files, max, modelLabel, onChange, onPickFromLibrary, label, hint, noun, }: ReferencePickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/generator/VersionHistory.d.ts

@@ -0,0 +1,13 @@
+import type { Version } from './model';
+interface VersionHistoryProps {
+    versions: Version[];
+    currentId: string | null;
+    disabled: boolean;
+    onSelect: (id: string) => void;
+}
+/**
+ * Historial de versiones con miniatura. Snowflake: el DS no tiene una lista seleccionable con
+ * imagen; cada fila es un botón con `aria-current` en la versión actual.
+ */
+export declare const VersionHistory: ({ versions, currentId, disabled, onSelect }: VersionHistoryProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/features/generator/generatorApi.d.ts

@@ -0,0 +1,71 @@
+export interface ImageModelInfo {
+    id: string;
+    label: string;
+    maxReferences: number;
+    sizes: string[];
+    aspectRatios: string[];
+    canEdit: boolean;
+    /** Admite la búsqueda de Google al generar (S4.14). */
+    grounding: boolean;
+}
+/** Fuentes y sugerencia de búsqueda que devuelve una imagen generada con búsqueda de Google. */
+export interface Grounding {
+    suggestions?: string;
+    /** Consultas web y de imágenes que hizo el modelo. */
+    queries: string[];
+    sources: {
+        title: string;
+        uri: string;
+    }[];
+}
+export interface GenerateParams {
+    prompt: string;
+    model: string;
+    aspectRatio: string;
+    imageSize?: string;
+    safety: boolean;
+    allowPeople: boolean;
+    grounding: boolean;
+    references: File[];
+}
+/** Editar la versión actual; `references` son los elementos para el cambio (S4.13). */
+export interface EditParams {
+    src: string;
+    instruction: string;
+    model: string;
+    references: File[];
+    safety: boolean;
+    allowPeople: boolean;
+    /** Proporción que debe conservar el resultado (la de la imagen base). */
+    aspectRatio?: string;
+}
+type Client = {
+    get: (url: string) => Promise<{
+        data: unknown;
+    }>;
+    post: (url: string, body: unknown) => Promise<{
+        data: unknown;
+    }>;
+};
+/** Mensaje del servidor (400 y 422 traen uno legible, diseño S4.2 D12) o el genérico dado. */
+export declare const errorMessage: (err: unknown, fallback: string) => string;
+/** Cliente de las rutas del Generador. Las imágenes viajan en multipart (el JSON admite 1 MB). */
+export declare const createGeneratorApi: (client: Client) => {
+    models(): Promise<{
+        models: ImageModelInfo[];
+        verified: boolean;
+    }>;
+    generate(p: GenerateParams): Promise<{
+        grounding?: Grounding | undefined;
+        src: string;
+        model: string;
+    }>;
+    edit(p: EditParams): Promise<{
+        grounding?: Grounding | undefined;
+        src: string;
+        model: string;
+    }>;
+    expand(prompt: string): Promise<string>;
+};
+export type GeneratorApi = ReturnType<typeof createGeneratorApi>;
+export {};

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

@@ -0,0 +1,60 @@
+import type { Grounding } from './generatorApi';
+/**
+ * Historial de versiones del Generador (diseño S4.2, D10). Vive en memoria como en el prototipo:
+ * la persistencia quedó en el parking lot del epic.
+ */
+export interface Version {
+    id: string;
+    /** Data URL de la imagen. */
+    src: string;
+    prompt: string;
+    /** Instrucción con la que se iteró; vacía en la versión original. */
+    instruction?: string;
+    /** Fuentes y sugerencia si se generó con búsqueda de Google (S4.14). */
+    grounding?: Grounding;
+}
+export interface GeneratorState {
+    versions: Version[];
+    currentId: string | null;
+}
+export type GeneratorAction = {
+    type: 'generated';
+    id: string;
+    src: string;
+    prompt: string;
+    grounding?: Grounding;
+} | {
+    type: 'iterated';
+    id: string;
+    src: string;
+    instruction: string;
+}
+/** Una imagen existente (subida o de la biblioteca) como Original, para editarla (S4.13). */
+ | {
+    type: 'loaded';
+    id: string;
+    src: string;
+    name: string;
+} | {
+    type: 'select';
+    id: string;
+}
+/** «Cambiar imagen» en el modo Editar (S4.13). */
+ | {
+    type: 'reset';
+};
+export declare const initialGenerator: GeneratorState;
+export declare const currentVersion: (s: GeneratorState) => Version | null;
+export declare const generatorReducer: (state: GeneratorState, action: GeneratorAction) => GeneratorState;
+export declare const versionLabel: (index: number) => string;
+/**
+ * «Imagen 28 sep» y, desde la segunda versión, « v3». La fecha se arma a mano: `toLocaleDateString`
+ * da «28-sep» o «28 sept» según la versión de ICU del navegador.
+ */
+export declare const defaultSaveName: (date: Date, index: number) => string;
+export declare const ITERATE_EXAMPLES: string[];
+/**
+ * La proporción del modelo más cercana a unas medidas (S4.13). Al editar con elementos, Gemini no
+ * conserva la proporción de la imagen base, así que se le pide la más parecida.
+ */
+export declare const closestRatio: (width: number, height: number, ratios: string[]) => string | undefined;

package/dist/admin/src/features/generator/useGeneratorApi.d.ts

@@ -0,0 +1,21 @@
+/** Cliente del Generador conectado al panel (sesión y notificaciones de Strapi). */
+export declare const useGeneratorApi: () => {
+    api: {
+        models(): Promise<{
+            models: import("./generatorApi").ImageModelInfo[];
+            verified: boolean;
+        }>;
+        generate(p: import("./generatorApi").GenerateParams): Promise<{
+            grounding?: import("./generatorApi").Grounding | undefined;
+            src: string;
+            model: string;
+        }>;
+        edit(p: import("./generatorApi").EditParams): Promise<{
+            grounding?: import("./generatorApi").Grounding | undefined;
+            src: string;
+            model: string;
+        }>;
+        expand(prompt: string): Promise<string>;
+    };
+    notify: (type: 'success' | 'danger' | 'warning', message: string) => void;
+};

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