@interware/content-generator 0.4.4 → 0.5.0

package/dist/server/src/bootstrap.d.ts

@@ -1,5 +1,5 @@
 import type { Core } from '@strapi/strapi';
 declare const bootstrap: ({ strapi }: {
     strapi: Core.Strapi;
-}) => void;
+}) => Promise<void>;
 export default bootstrap;

package/dist/server/src/content-types/index.d.ts

@@ -1,2 +1,67 @@
-declare const _default: {};
+declare const _default: {
+    template: {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                'content-manager': {
+                    visible: boolean;
+                };
+                'content-type-builder': {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                name: {
+                    type: string;
+                    required: boolean;
+                    maxLength: number;
+                };
+                folder: {
+                    type: string;
+                    default: string;
+                };
+                width: {
+                    type: string;
+                    required: boolean;
+                };
+                height: {
+                    type: string;
+                    required: boolean;
+                };
+                background: {
+                    type: string;
+                    default: string;
+                };
+                safeMargin: {
+                    type: string;
+                    default: number;
+                };
+                gridUnit: {
+                    type: string;
+                    default: number;
+                };
+                layers: {
+                    type: string;
+                    required: boolean;
+                };
+                baseId: {
+                    type: string;
+                };
+                replacesBase: {
+                    type: string;
+                };
+            };
+        };
+    };
+};
 export default _default;

package/dist/server/src/content-types/template/index.d.ts

@@ -0,0 +1,65 @@
+declare const _default: {
+    schema: {
+        kind: string;
+        collectionName: string;
+        info: {
+            singularName: string;
+            pluralName: string;
+            displayName: string;
+            description: string;
+        };
+        options: {
+            draftAndPublish: boolean;
+        };
+        pluginOptions: {
+            'content-manager': {
+                visible: boolean;
+            };
+            'content-type-builder': {
+                visible: boolean;
+            };
+        };
+        attributes: {
+            name: {
+                type: string;
+                required: boolean;
+                maxLength: number;
+            };
+            folder: {
+                type: string;
+                default: string;
+            };
+            width: {
+                type: string;
+                required: boolean;
+            };
+            height: {
+                type: string;
+                required: boolean;
+            };
+            background: {
+                type: string;
+                default: string;
+            };
+            safeMargin: {
+                type: string;
+                default: number;
+            };
+            gridUnit: {
+                type: string;
+                default: number;
+            };
+            layers: {
+                type: string;
+                required: boolean;
+            };
+            baseId: {
+                type: string;
+            };
+            replacesBase: {
+                type: string;
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/template/schema.d.ts

@@ -0,0 +1,69 @@
+/**
+ * «Mis templates» (ADR-004, diseño S4.6 D1). Oculto en Content Manager y en Content-Type Builder:
+ * solo se edita desde el Estudio de imágenes. Las capas van en JSON y se validan en el servicio.
+ */
+declare const _default: {
+    kind: string;
+    collectionName: string;
+    info: {
+        singularName: string;
+        pluralName: string;
+        displayName: string;
+        description: string;
+    };
+    options: {
+        draftAndPublish: boolean;
+    };
+    pluginOptions: {
+        'content-manager': {
+            visible: boolean;
+        };
+        'content-type-builder': {
+            visible: boolean;
+        };
+    };
+    attributes: {
+        name: {
+            type: string;
+            required: boolean;
+            maxLength: number;
+        };
+        folder: {
+            type: string;
+            default: string;
+        };
+        width: {
+            type: string;
+            required: boolean;
+        };
+        height: {
+            type: string;
+            required: boolean;
+        };
+        background: {
+            type: string;
+            default: string;
+        };
+        safeMargin: {
+            type: string;
+            default: number;
+        };
+        gridUnit: {
+            type: string;
+            default: number;
+        };
+        layers: {
+            type: string;
+            required: boolean;
+        };
+        /** Base de la que se copió (origen). */
+        baseId: {
+            type: string;
+        };
+        /** Si está, esta fila es la versión editada de esa plantilla base (S4.15): una por base. */
+        replacesBase: {
+            type: string;
+        };
+    };
+};
+export default _default;

package/dist/server/src/controllers/config.d.ts

@@ -2,7 +2,9 @@ import type { Core } from '@strapi/strapi';
 declare const config: ({ strapi }: {
     strapi: Core.Strapi;
 }) => {
+    /** Devuelve si cada credencial está guardada y sus últimos 4 caracteres, nunca el valor. */
     get(ctx: any): Promise<void>;
+    /** Escribe solo las credenciales conocidas que llegan como texto no vacío. */
     set(ctx: any): Promise<void>;
 };
 export default config;

package/dist/server/src/controllers/controller.d.ts

@@ -5,16 +5,11 @@ declare const controller: ({ strapi }: {
     getArticles(ctx: any): Promise<unknown>;
     getCategories(ctx: any): Promise<unknown>;
     getUsers(ctx: any): Promise<unknown>;
-    getImages(ctx: any): Promise<unknown>;
-    deleteImage(ctx: any): Promise<unknown>;
     generateArticle(ctx: any): Promise<void>;
     generateImageForArticle(ctx: any): Promise<void>;
-    generateImage(ctx: any): Promise<void>;
     downloadFile(ctx: any): Promise<void>;
     generateVideo(ctx: any): Promise<void>;
     publishToLinkedIn(ctx: any): Promise<void>;
     publishToFacebook(ctx: any): Promise<void>;
-    get(ctx: any): Promise<void>;
-    set(ctx: any): Promise<void>;
 };
 export default controller;

package/dist/server/src/controllers/image-studio.d.ts

@@ -0,0 +1,23 @@
+import type { Core } from '@strapi/strapi';
+type Ctx = {
+    request: {
+        body?: Record<string, unknown>;
+        files?: Record<string, never>;
+    };
+    status: number;
+    body: unknown;
+};
+/**
+ * Rutas del Generador (diseño S4.2). Mapea los errores (D12): entrada inválida → 400, bloqueo del
+ * modelo → 422 con el motivo, cualquier otro → 502 genérico; el detalle queda en el log del
+ * servidor y nunca llega al panel (puede incluir datos de la llave o de la cuenta).
+ */
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    models: (ctx: Ctx) => Promise<void>;
+    generate: (ctx: Ctx) => Promise<void>;
+    edit: (ctx: Ctx) => Promise<void>;
+    expand: (ctx: Ctx) => Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -5,17 +5,12 @@ declare const _default: {
         getArticles(ctx: any): Promise<unknown>;
         getCategories(ctx: any): Promise<unknown>;
         getUsers(ctx: any): Promise<unknown>;
-        getImages(ctx: any): Promise<unknown>;
-        deleteImage(ctx: any): Promise<unknown>;
         generateArticle(ctx: any): Promise<void>;
         generateImageForArticle(ctx: any): Promise<void>;
-        generateImage(ctx: any): Promise<void>;
         downloadFile(ctx: any): Promise<void>;
         generateVideo(ctx: any): Promise<void>;
         publishToLinkedIn(ctx: any): Promise<void>;
         publishToFacebook(ctx: any): Promise<void>;
-        get(ctx: any): Promise<void>;
-        set(ctx: any): Promise<void>;
     };
     config: ({ strapi }: {
         strapi: import("@strapi/types/dist/core").Strapi;
@@ -23,5 +18,133 @@ declare const _default: {
         get(ctx: any): Promise<void>;
         set(ctx: any): Promise<void>;
     };
+    'image-studio': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        models: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+                files?: Record<string, never>;
+            };
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        generate: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+                files?: Record<string, never>;
+            };
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        edit: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+                files?: Record<string, never>;
+            };
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        expand: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+                files?: Record<string, never>;
+            };
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+    };
+    templates: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        list: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        create: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        findOne: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        update: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        remove: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        saveBase: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        restoreBase: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        folders: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        createFolder: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        renameFolder: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+        deleteFolder: (ctx: {
+            request: {
+                body?: Record<string, unknown>;
+            };
+            params: Record<string, string>;
+            status: number;
+            body: unknown;
+        }) => Promise<void>;
+    };
 };
 export default _default;

package/dist/server/src/controllers/templates.d.ts

@@ -0,0 +1,26 @@
+import type { Core } from '@strapi/strapi';
+type Ctx = {
+    request: {
+        body?: Record<string, unknown>;
+    };
+    params: Record<string, string>;
+    status: number;
+    body: unknown;
+};
+/** Rutas de «Mis templates» (diseño S4.6): 400 entrada inválida, 404 inexistente, 500 el resto. */
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    list: (ctx: Ctx) => Promise<void>;
+    create: (ctx: Ctx) => Promise<void>;
+    findOne: (ctx: Ctx) => Promise<void>;
+    update: (ctx: Ctx) => Promise<void>;
+    remove: (ctx: Ctx) => Promise<void>;
+    saveBase: (ctx: Ctx) => Promise<void>;
+    restoreBase: (ctx: Ctx) => Promise<void>;
+    folders: (ctx: Ctx) => Promise<void>;
+    createFolder: (ctx: Ctx) => Promise<void>;
+    renameFolder: (ctx: Ctx) => Promise<void>;
+    deleteFolder: (ctx: Ctx) => Promise<void>;
+};
+export default _default;

package/dist/server/src/image-studio/geminiConfig.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { GenerateContentConfig, ImageConfig, Part, SafetySetting, Tool } from '@google/genai';
+/**
+ * Configuración de `generateContent` para las imágenes del Estudio (S4.14). Todo se arma con los
+ * tipos de `@google/genai` (`genai.d.ts`, 1.49): nada de literales sueltos en las llamadas.
+ *
+ * El SDK sirve a dos backends. Con llave de API (Gemini API, lo que usa el plugin hoy) rechaza
+ * `personGeneration`, así que personas se pide en el prompt; con Vertex AI va en `ImageConfig`.
+ * Decisión de Israel (2026-09-30): se migrará a Vertex; entonces basta con pasar `'vertex'`.
+ */
+export type Backend = 'gemini-api' | 'vertex';
+/** Única forma de pedir «sin personas» en la Gemini API. */
+export declare const PEOPLE_CLAUSE = "STRICTLY NO people, NO humans, NO faces, NO hands.";
+/** Seguridad activa → bloqueo medio; apagada → solo lo alto. `BLOCK_NONE` no aplica a llaves de API (D6). */
+export declare const safetySettings: (safety: boolean) => SafetySetting[];
+export interface ImageConfigInput {
+    aspectRatio?: string;
+    imageSize?: string;
+    allowPeople: boolean;
+}
+export declare const imageConfig: ({ aspectRatio, imageSize, allowPeople }: ImageConfigInput, backend?: Backend) => ImageConfig;
+/** El texto del prompt; en la Gemini API lleva la cláusula de personas cuando no se permiten. */
+export declare const promptPart: (text: string, allowPeople: boolean, backend?: Backend) => Part;
+/** Búsqueda de Google con resultados web y de imágenes (Nano Banana 2, D5). */
+export declare const searchTool: () => Tool;
+export interface GenerateConfigInput extends ImageConfigInput {
+    aspectRatio: string;
+    safety: boolean;
+    grounding: boolean;
+}
+export declare const generateConfig: ({ aspectRatio, imageSize, allowPeople, safety, grounding }: GenerateConfigInput, backend?: Backend) => GenerateContentConfig;
+export interface EditConfigInput {
+    safety: boolean;
+    allowPeople: boolean;
+    /** La de la imagen base: con varias imágenes el modelo no la conserva solo (S4.13). */
+    aspectRatio?: string;
+}
+export declare const editConfig: ({ safety, allowPeople, aspectRatio }: EditConfigInput, backend?: Backend) => GenerateContentConfig;
+export declare const inlinePart: (bytes: Buffer, mimeType: string) => Part;

package/dist/server/src/image-studio/models.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Catálogo de modelos de imagen del Generador (diseño S4.2, D1). Es la única lista: cuando Google
+ * cambie o retire un modelo se edita aquí. `GET /image-studio/models` la filtra contra
+ * `ai.models.list()` (D2). El primero es el modelo por defecto.
+ */
+export interface ImageModelInfo {
+    id: string;
+    label: string;
+    /** Imágenes de referencia que acepta. El panel limita a 6 como el prototipo (la API admite hasta 14). */
+    maxReferences: number;
+    /** Tamaños de salida que admite (`imageSize`, con K mayúscula); vacío = el modelo decide. */
+    sizes: string[];
+    aspectRatios: string[];
+    /** Puede editar una imagen existente con una instrucción (iterar). */
+    canEdit: boolean;
+    /** Admite la búsqueda de Google al generar (S4.14; según la doc, solo 3.1 Flash Image). */
+    grounding: boolean;
+}
+/**
+ * Modelos vigentes según la doc de Google (S4.12, 2026-09-29): Imagen está apagado. Las etiquetas
+ * son los nombres comerciales: Nano Banana 2 = 3.1 Flash, 2 Lite = 3.1 Flash Lite, Pro = 3 Pro, sin
+ * número = 2.5 Flash. Cada modelo
+ * estable tiene su variante `-preview` por si la llave solo tiene acceso a esa; `availableModels`
+ * oculta la preview cuando la estable también aparece.
+ */
+export declare const IMAGE_MODELS: ImageModelInfo[];
+export declare const findModel: (id: string | undefined) => ImageModelInfo;
+/**
+ * Catálogo filtrado por los nombres que devuelve `ai.models.list()` («models/<id>»). Sin lista, o si
+ * ninguno coincide (la API cambió de formato), se devuelve el catálogo completo sin verificar para
+ * no dejar el Generador vacío.
+ */
+export declare const availableModels: (listed: string[] | null) => {
+    models: ImageModelInfo[];
+    verified: boolean;
+};
+/** Modelo para iterar: el elegido si edita; si no, el primero del catálogo (D8). */
+export declare const editModelFor: (id: string | undefined) => ImageModelInfo;

package/dist/server/src/image-studio/prompt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Un prompt en una sola línea y saneado (S4.14): Gemini responde peor a saltos y espacios
+ * repetidos. Segunda línea de defensa; la validación está en `validate.ts`.
+ */
+export declare const cleanPrompt: (text: string) => string;
+/** Instrucción de «Expandir idea» (D9). */
+export declare const EXPAND_INSTRUCTION: (concept: string) => string;

package/dist/server/src/image-studio/validate.d.ts

@@ -0,0 +1,41 @@
+import { checkPrompt } from '../../../admin/src/lib/promptRules';
+import type { ImageModelInfo } from './models';
+/** Entrada inválida del panel: el controlador la responde como 400 (diseño S4.2, D12). */
+export declare class InputError extends Error {
+}
+/** Archivo de formidable tal como lo deja `ctx.request.files`. */
+export interface UploadedFile {
+    filepath: string;
+    mimetype: string | null;
+    size: number;
+    originalFilename?: string | null;
+}
+type Fields = Record<string, unknown>;
+type Files = Record<string, UploadedFile | UploadedFile[] | undefined>;
+/** Prompt saneado y validado con las reglas compartidas con el panel (S4.14, D1). */
+export declare const clean: (text: string, labels?: Parameters<typeof checkPrompt>[1]) => string;
+export interface GenerateInput {
+    prompt: string;
+    model: ImageModelInfo;
+    aspectRatio: string;
+    imageSize?: string;
+    safety: boolean;
+    allowPeople: boolean;
+    /** Búsqueda de Google; `false` si el modelo no la admite (S4.14, D5). */
+    grounding: boolean;
+    references: UploadedFile[];
+}
+export declare const parseGenerateInput: (fields: Fields, files: Files) => GenerateInput;
+export interface EditInput {
+    instruction: string;
+    model: ImageModelInfo;
+    image: UploadedFile;
+    /** Elementos para el cambio (un logo que colocar, S4.13). */
+    references: UploadedFile[];
+    safety: boolean;
+    allowPeople: boolean;
+    /** La proporción de la imagen base, si el modelo la admite: con varias imágenes no la conserva solo. */
+    aspectRatio?: string;
+}
+export declare const parseEditInput: (fields: Fields, files: Files) => EditInput;
+export {};