@interware/content-generator 0.4.4 → 0.6.0

package/dist/admin/src/features/templates/model/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Modelo de capas del editor de plantillas (ADR-004). Es el contrato que comparten el lienzo, la
+ * exportación y, desde S4.6, la persistencia en el CMS.
+ */
+export type LayerType = 'text' | 'list' | 'quote' | 'rect' | 'shape' | 'badge' | 'logo' | 'image' | 'icon' | 'avatar' | 'qr';
+/** Roles anteriores a S4.16; hoy `font` es el id del catálogo (`fonts/catalog.ts`) y estos se leen como Texta e Inter. */
+export type FontRole = 'display' | 'body';
+export type ShapeKind = 'rect' | 'rounded' | 'circle' | 'triangle' | 'star' | 'line' | 'arrow' | 'hexagon';
+export interface Shadow {
+    x: number;
+    y: number;
+    blur: number;
+    color: string;
+    opacity: number;
+}
+interface LayerBase {
+    id: string;
+    type: LayerType;
+    label: string;
+    x: number;
+    y: number;
+    opacity?: number;
+    rotate?: number;
+    hidden?: boolean;
+    locked?: boolean;
+    userAdded?: boolean;
+}
+interface TypographyProps {
+    fontSize: number;
+    fontWeight: number;
+    color: string;
+    /** Id del catálogo de tipografías, o un rol anterior (`display`, `body`). */
+    font?: string;
+    fontStyle?: 'normal' | 'italic';
+    lineHeight?: number;
+    letterSpacing?: string;
+    textTransform?: 'none' | 'uppercase';
+}
+export interface TextLayer extends LayerBase, TypographyProps {
+    type: 'text';
+    w: number;
+    content: string;
+    textAlign?: 'left' | 'center' | 'right';
+}
+export interface ListLayer extends LayerBase, TypographyProps {
+    type: 'list';
+    w: number;
+    items: string[];
+    ordered: boolean;
+}
+export interface QuoteLayer extends LayerBase, TypographyProps {
+    type: 'quote';
+    w: number;
+    content: string;
+    accentColor: string;
+}
+export interface RectLayer extends LayerBase {
+    type: 'rect';
+    w: number;
+    h: number;
+    color: string;
+    gradient?: string;
+}
+export interface ShapeLayer extends LayerBase {
+    type: 'shape';
+    w: number;
+    h: number;
+    shape: ShapeKind;
+    color: string;
+    color2?: string;
+    fillType?: 'solid' | 'linear' | 'radial';
+    gradAngle?: number;
+    radius?: number;
+    strokeWidth?: number;
+    strokeColor?: string;
+    shadow?: Shadow | null;
+}
+export interface BadgeLayer extends LayerBase, TypographyProps {
+    type: 'badge';
+    content: string;
+    paddingX: number;
+    paddingY: number;
+    bg: string;
+}
+export interface LogoLayer extends LayerBase {
+    type: 'logo';
+    color: string;
+    logoScale: number;
+}
+export interface ImageLayer extends LayerBase {
+    type: 'image';
+    w: number;
+    h: number;
+    /** URL de origen (Media Library o data URL de un archivo subido). */
+    src: string;
+    fileId?: number;
+    fit?: 'cover' | 'contain';
+    radius?: number;
+    bgMode?: boolean;
+    /** Imagen antes de quitarle el fondo, para «Restaurar original». */
+    srcOriginal?: string;
+    /** Geometría previa a «usar como fondo», para poder liberarla. */
+    prev?: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+export interface IconLayer extends LayerBase {
+    type: 'icon';
+    icon: string;
+    size: number;
+    color: string;
+}
+export interface AvatarLayer extends LayerBase {
+    type: 'avatar';
+    size: number;
+    bg: string;
+    initials: string;
+    border: boolean;
+    borderWidth: number;
+    borderColor: string;
+    src?: string;
+}
+export interface QrLayer extends LayerBase {
+    type: 'qr';
+    size: number;
+    color: string;
+    bg: string;
+    url: string;
+}
+export type Layer = TextLayer | ListLayer | QuoteLayer | RectLayer | ShapeLayer | BadgeLayer | LogoLayer | ImageLayer | IconLayer | AvatarLayer | QrLayer;
+/** Parche aplicable a cualquier capa: el editor sabe qué campos tiene cada tipo. */
+export type LayerPatch = Partial<Omit<Layer, 'id' | 'type'>> & Record<string, unknown>;
+export interface Template {
+    id: string;
+    name: string;
+    category: string;
+    tag: string;
+    width: number;
+    height: number;
+    background: string;
+    safeMargin: number;
+    gridUnit: number;
+    layers: Layer[];
+    /** Solo en «Mis templates» (S4.6): id en el CMS, carpeta y plantilla base de origen. */
+    documentId?: string;
+    folder?: string;
+    baseId?: string;
+    /** Versión editada de esa plantilla base, guardada en el CMS para todos (S4.15). */
+    replacesBase?: string;
+}
+export {};

package/dist/admin/src/features/templates/model/viewport.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Vista del lienzo (diseño S4.9, D9): escala y desplazamiento de la esquina superior izquierda de la
+ * pieza dentro del viewport, en píxeles de pantalla. Un punto `c` del lienzo se ve en
+ * `pan + c * scale`.
+ */
+export interface View {
+    scale: number;
+    pan: {
+        x: number;
+        y: number;
+    };
+}
+export declare const MIN_ZOOM = 0.05;
+export declare const MAX_ZOOM = 4;
+export declare const clampZoom: (z: number) => number;
+/** Zoom a `nextScale` dejando fijo el punto del lienzo que está bajo `cursor` (pellizco, ⌘ + rueda). */
+export declare const zoomAt: (view: View, cursor: {
+    x: number;
+    y: number;
+}, nextScale: number) => View;
+/** Desplaza la vista (dos dedos, arrastre del fondo). */
+export declare const panBy: (view: View, dx: number, dy: number) => View;
+/**
+ * «Ajustar»: la escala que hace caber la pieza en el espacio libre entre los paneles flotantes
+ * (nunca más de 100 %) y el desplazamiento que la centra ahí (diseño S4.9, D8).
+ */
+export declare const fitView: (viewport: {
+    w: number;
+    h: number;
+}, insets: {
+    left: number;
+    right: number;
+}, piece: {
+    w: number;
+    h: number;
+}, padding?: number, rulers?: number) => View;

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

@@ -0,0 +1,7 @@
+interface IWLogoProps {
+    color: string;
+    scale?: number;
+}
+/** Logotipo InterWare: punto rojo, «i», «w» y la palabra InterWare. 170 × 36 a escala 1. */
+export declare const IWLogo: ({ color, scale }: IWLogoProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import type { Layer, Template } from '../model/types';
+interface LayerCanvasProps {
+    template: Pick<Template, 'width' | 'height' | 'background'>;
+    layers: Layer[];
+    /** Escala de presentación; la exportación usa 1. */
+    scale?: number;
+}
+/** Imágenes usadas como fondo primero, luego el resto en su orden; las ocultas no se pintan. */
+export declare const visibleLayers: (layers: Layer[]) => Layer[];
+/** Pieza completa: fondo de la plantilla y sus capas, escalada para presentación. */
+export declare const LayerCanvas: import("react").ForwardRefExoticComponent<LayerCanvasProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * Declara en el documento del panel las fuentes del catálogo (S4.16): las del CMS por su ruta y las
+ * subidas como data URL. Si un archivo falta, el navegador cae a la fuente de respaldo.
+ */
+export declare const BrandFonts: () => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import type { ComponentType, SVGProps } from 'react';
+import type { ICON_LIBRARY } from '../model/presets';
+type IconComponent = ComponentType<SVGProps<SVGSVGElement>>;
+/**
+ * Íconos de @strapi/icons que pueden ir dentro de una pieza (lista en model/presets). Solo los que
+ * existen también en la versión que resuelve el CMS (2.0.0-rc.18 en web-cms): `Graph` y `TrendUp`
+ * no están ahí y rompen el panel.
+ */
+export declare const CONTENT_ICONS: Record<(typeof ICON_LIBRARY)[number], IconComponent>;
+export {};

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

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import type { Layer } from '../model/types';
+/**
+ * Una capa en coordenadas del lienzo (sin escala). Es el único render de capas: lo usan el editor,
+ * las miniaturas y la exportación, para que lo que se ve sea lo que se descarga.
+ */
+export declare const LayerView: import("react").MemoExoticComponent<({ layer }: {
+    layer: Layer;
+}) => import("react/jsx-runtime").JSX.Element>;

package/dist/admin/src/features/templates/store/persist.d.ts

@@ -0,0 +1,41 @@
+import type { Layer, Template } from '../model/types';
+import type { StoredTemplate, TemplateInput } from './templatesApi';
+/** Sube un blob a la carpeta «Templates» de la Media Library y devuelve su id y URL. */
+export type Upload = (blob: Blob, name: string) => Promise<{
+    id: number;
+    url: string;
+}>;
+/** Solo para pruebas. */
+export declare const forgetUploads: () => void;
+/**
+ * Template del editor → contrato del servidor (diseño S4.6, D6). Cada imagen en data URL se sube una
+ * sola vez a la Media Library y se reemplaza por su URL y `fileId`; `srcOriginal` se descarta
+ * (la imagen previa a quitar el fondo no se conserva). ADR-004: nada de data URLs en el template.
+ */
+export declare const toStored: (template: Template, { name, folder }: {
+    name: string;
+    folder: string;
+}, upload: Upload) => Promise<TemplateInput>;
+/**
+ * Contrato del servidor → capas del editor (diseño S4.6, D7): las imágenes remotas pasan a data URL
+ * para que la exportación no contamine el lienzo. Las que fallan quedan con su URL y se cuentan.
+ */
+export declare const toEditable: (layers: Layer[], toDataUrl: (url: string) => Promise<string>) => Promise<{
+    layers: Layer[];
+    failed: number;
+}>;
+/** «16:9», «4:5»… o «~1.9:1» si la proporción no es simple. */
+export declare const ratioTag: (w: number, h: number) => string;
+export declare const fromStored: (t: StoredTemplate) => Template;
+/**
+ * Plantillas base con sus versiones editadas (S4.15): donde hay una editada se usa esa, con la
+ * categoría de la base; las demás quedan como en el código.
+ */
+export declare const mergeBases: (bases: Template[], edited: StoredTemplate[]) => Template[];
+/** Tamaños del prototipo para «Crear nuevo lienzo» (diseño S4.6, D9). */
+export declare const SIZE_PRESETS: {
+    name: string;
+    w: number;
+    h: number;
+}[];
+export declare const blankTemplate: (width: number, height: number) => Template;

package/dist/admin/src/features/templates/store/templatesApi.d.ts

@@ -0,0 +1,49 @@
+import type { Layer } from '../model/types';
+export interface TemplateInput {
+    name: string;
+    folder: string;
+    width: number;
+    height: number;
+    background: string;
+    safeMargin: number;
+    gridUnit: number;
+    layers: Layer[];
+    baseId?: string;
+}
+export interface StoredTemplate extends TemplateInput {
+    documentId: string;
+    updatedAt: string;
+    /** Versión editada de esa plantilla base (S4.15). */
+    replacesBase?: string;
+}
+type Client = {
+    get: (url: string) => Promise<{
+        data: unknown;
+    }>;
+    post: (url: string, body: unknown) => Promise<{
+        data: unknown;
+    }>;
+    put: (url: string, body: unknown) => Promise<{
+        data: unknown;
+    }>;
+    del: (url: string) => Promise<{
+        data: unknown;
+    }>;
+};
+/** Cliente de las rutas de «Mis templates» (diseño S4.6). */
+export declare const createTemplatesApi: (c: Client) => {
+    list: () => Promise<StoredTemplate[]>;
+    create: (t: TemplateInput) => Promise<StoredTemplate>;
+    update: (documentId: string, patch: Partial<TemplateInput>) => Promise<StoredTemplate>;
+    remove: (documentId: string) => Promise<void>;
+    /** Guarda la versión editada de una base; la crea la primera vez (S4.15). */
+    saveBase: (baseId: string, t: TemplateInput) => Promise<StoredTemplate>;
+    /** Vuelve a la versión de InterWare. */
+    restoreBase: (baseId: string) => Promise<void>;
+    folders: () => Promise<string[]>;
+    createFolder: (path: string) => Promise<string[]>;
+    renameFolder: (from: string, to: string) => Promise<string[]>;
+    deleteFolder: (path: string) => Promise<string[]>;
+};
+export type TemplatesApi = ReturnType<typeof createTemplatesApi>;
+export {};

package/dist/admin/src/features/templates/store/useMyTemplates.d.ts

@@ -0,0 +1,19 @@
+import type { Template } from '../model/types';
+import type { StoredTemplate } from './templatesApi';
+/** Estado de «Mis templates» y sus carpetas con las operaciones del selector (diseño S4.6). */
+export declare const useMyTemplates: () => {
+    templates: StoredTemplate[];
+    editedBases: StoredTemplate[];
+    folders: string[];
+    loading: boolean;
+    reload: () => Promise<void>;
+    rename: (t: Template, name: string) => Promise<void>;
+    /** Una base se duplica en la raíz; un template propio, en su misma carpeta. */
+    duplicate: (t: Template) => Promise<void>;
+    move: (t: Template, folder: string) => Promise<void>;
+    remove: (t: Template) => Promise<void>;
+    restoreBase: (t: Template) => Promise<void>;
+    createFolder: (parent: string, name: string) => Promise<void>;
+    renameFolder: (path: string, name: string) => Promise<void>;
+    deleteFolder: (path: string) => Promise<void>;
+};

package/dist/admin/src/features/templates/store/useTemplateSaving.d.ts

@@ -0,0 +1,14 @@
+import type { Template } from '../model/types';
+/**
+ * Guardar desde el editor (diseño S4.6, D8): crear un template nuevo o actualizar uno propio. Sube
+ * antes las imágenes en data URL y notifica el resultado; en error devuelve `null`.
+ */
+export declare const useTemplateSaving: () => {
+    saveNew: (template: Template, target: {
+        name: string;
+        folder: string;
+    }) => Promise<Template | null>;
+    saveExisting: (template: Template) => Promise<Template | null>;
+    saveBase: (template: Template) => Promise<Template | null>;
+    folders: () => Promise<string[]>;
+};

package/dist/admin/src/features/templates/store/useTemplatesApi.d.ts

@@ -0,0 +1,23 @@
+import type { Upload } from './persist';
+/**
+ * Cliente de «Mis templates» conectado al panel, más la subida de imágenes a la carpeta «Templates»
+ * (diseño S4.6, D6). Como la biblioteca tiene raíz en «Generated», queda en «Generated/Templates»
+ * (S4.11). La carpeta se busca o se crea una vez por sesión del hook.
+ */
+export declare const useTemplatesApi: () => {
+    api: {
+        list: () => Promise<import("./templatesApi").StoredTemplate[]>;
+        create: (t: import("./templatesApi").TemplateInput) => Promise<import("./templatesApi").StoredTemplate>;
+        update: (documentId: string, patch: Partial<import("./templatesApi").TemplateInput>) => Promise<import("./templatesApi").StoredTemplate>;
+        remove: (documentId: string) => Promise<void>;
+        saveBase: (baseId: string, t: import("./templatesApi").TemplateInput) => Promise<import("./templatesApi").StoredTemplate>;
+        restoreBase: (baseId: string) => Promise<void>;
+        folders: () => Promise<string[]>;
+        createFolder: (path: string) => Promise<string[]>;
+        renameFolder: (from: string, to: string) => Promise<string[]>;
+        deleteFolder: (path: string) => Promise<string[]>;
+    };
+    upload: Upload;
+    toDataUrl: (url: string) => Promise<string>;
+    notify: (type: 'success' | 'danger' | 'warning', message: string) => void;
+};

package/dist/admin/src/hooks/useAdminTheme.d.ts

@@ -0,0 +1,8 @@
+type Scheme = 'light' | 'dark';
+/**
+ * Tema del panel de Strapi para el `ThemeProvider` del plugin (S4.10; `PluginProviders`). Sin esto el
+ * plugin se pintaba siempre claro aunque el panel estuviera en oscuro. Con «system» sigue los
+ * cambios del sistema operativo.
+ */
+export declare const useAdminTheme: () => Scheme;
+export {};

package/dist/admin/src/hooks/useThemeColors.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="custom" />
+import { lightTheme } from '@strapi/design-system';
+type Colors = typeof lightTheme.colors;
+/**
+ * Colores del tema activo para los snowflakes que pintan con `style` (bordes, reglas, acentos), así
+ * se ven bien en el tema claro y en el oscuro (S4.10). Sin proveedor cae al tema claro.
+ */
+export declare const useThemeColors: () => Colors;
+export {};

package/dist/admin/src/lib/dataUrl.d.ts

@@ -0,0 +1,6 @@
+/** Bytes de una data URL, en base64 o codificada como texto (el SVG de html-to-image). */
+export declare const dataUrlToBytes: (dataUrl: string) => Uint8Array;
+/**
+ * Blob de una data URL sin `fetch`: la CSP del admin limita `connect-src` y no incluye `data:`.
+ */
+export declare const dataUrlToBlob: (dataUrl: string) => Blob;

package/dist/admin/src/lib/promptRules.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reglas del prompt del Generador (S4.14, D1). Módulo puro que usan el panel (aviso antes de
+ * enviar) y el servidor (la autoridad: responde 400). Sin dependencias para poder compartirse.
+ */
+export declare const PROMPT_MAX = 2000;
+/** Texto limpio: NFC, sin control, invisibles ni etiquetas, con los espacios colapsados. */
+export declare const sanitizePrompt: (text: string) => string;
+export type PromptCheck = {
+    ok: true;
+    text: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** Textos de los errores: `label` para el máximo, `empty` para el vacío. */
+export interface PromptLabels {
+    label: string;
+    empty: string;
+}
+export declare const PROMPT_LABELS: PromptLabels;
+export declare const INSTRUCTION_LABELS: PromptLabels;
+/** Valida después de limpiar. Lo que excede el máximo se rechaza, no se recorta (D2). */
+export declare const checkPrompt: (text: string, { label, empty }?: PromptLabels) => PromptCheck;

package/dist/admin/src/lib/use-cases/articles/index.d.ts

@@ -1,5 +1,16 @@
 import { FetchOptions } from '@strapi/strapi/admin';
 declare const useArticles: () => {
-    getArticles: (config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any>(url: string, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
+    getArticles: (config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<{
+        (url: string, config: FetchOptions & {
+            responseType: "blob";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<Blob>>;
+        (url: string, config: FetchOptions & {
+            responseType: "text";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<string>>;
+        (url: string, config: FetchOptions & {
+            responseType: "arrayBuffer";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<ArrayBuffer>>;
+        <TData = unknown>(url: string, config?: FetchOptions | undefined): Promise<import("@strapi/strapi/admin").FetchResponse<TData>>;
+    }>>;
 };
 export { useArticles };

package/dist/admin/src/lib/use-cases/categories/index.d.ts

@@ -1,5 +1,16 @@
 import { FetchOptions } from '@strapi/strapi/admin';
 declare const useCategories: () => {
-    getCategories: (config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any>(url: string, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
+    getCategories: (config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<{
+        (url: string, config: FetchOptions & {
+            responseType: "blob";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<Blob>>;
+        (url: string, config: FetchOptions & {
+            responseType: "text";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<string>>;
+        (url: string, config: FetchOptions & {
+            responseType: "arrayBuffer";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<ArrayBuffer>>;
+        <TData = unknown>(url: string, config?: FetchOptions | undefined): Promise<import("@strapi/strapi/admin").FetchResponse<TData>>;
+    }>>;
 };
 export { useCategories };

package/dist/admin/src/lib/use-cases/facebook/index.d.ts

@@ -1,5 +1,5 @@
 import { FetchOptions } from '@strapi/strapi/admin';
 declare const usePublishFacebook: () => {
-    publishToFacebook: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any, TSend = any>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
+    publishToFacebook: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = unknown, TSend = unknown>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
 };
 export { usePublishFacebook };

package/dist/admin/src/lib/use-cases/generate-content/index.d.ts

@@ -1,6 +1,6 @@
 import { FetchOptions } from '@strapi/strapi/admin';
 declare const useGenerateContent: () => {
-    generateContent: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any, TSend = any>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
-    generateImage: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any, TSend = any>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
+    generateContent: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = unknown, TSend = unknown>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
+    generateImage: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = unknown, TSend = unknown>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
 };
 export { useGenerateContent };

package/dist/admin/src/lib/use-cases/images/index.d.ts

@@ -1,8 +1,5 @@
 import { FetchOptions } from '@strapi/strapi/admin';
 declare const useImages: () => {
-    getImages: () => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any>(url: string, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
-    deleteImage: (config: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData_1 = any>(url: string, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData_1>>)>>;
-    generateImageWithConfig: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData_2 = any, TSend = any>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData_2>>)>>;
-    generateVideoWithScenes: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData_2 = any, TSend = any>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData_2>>)>>;
+    generateVideoWithScenes: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = unknown, TSend = unknown>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
 };
 export { useImages };

package/dist/admin/src/lib/use-cases/linkedin/index.d.ts

@@ -1,5 +1,5 @@
 import { FetchOptions } from '@strapi/strapi/admin';
 declare const usePublishLinkedIn: () => {
-    publishToLinkedIn: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any, TSend = any>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
+    publishToLinkedIn: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = unknown, TSend = unknown>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
 };
 export { usePublishLinkedIn };

package/dist/admin/src/lib/use-cases/settings/index.d.ts

@@ -1,6 +1,18 @@
 import { FetchOptions } from '@strapi/strapi/admin';
 declare const useSettings: () => {
-    getSettings: (config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any>(url: string, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
-    setSettings: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData_1 = any, TSend = any>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData_1>>)>>;
+    getSettings: (config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<{
+        (url: string, config: FetchOptions & {
+            responseType: "blob";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<Blob>>;
+        (url: string, config: FetchOptions & {
+            responseType: "text";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<string>>;
+        (url: string, config: FetchOptions & {
+            responseType: "arrayBuffer";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<ArrayBuffer>>;
+        <TData = unknown>(url: string, config?: FetchOptions | undefined): Promise<import("@strapi/strapi/admin").FetchResponse<TData>>;
+    }>>;
+    setSettings: (data: any, config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData_1 = unknown, TSend = unknown>(url: string, data?: TSend | undefined, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData_1>>)>>;
+    removeVertex: () => Promise<import("@strapi/strapi/admin").FetchResponse<unknown>>;
 };
 export { useSettings };

package/dist/admin/src/lib/use-cases/users/index.d.ts

@@ -1,5 +1,16 @@
 import { FetchOptions } from '@strapi/strapi/admin';
 declare const useUsers: () => {
-    getUsers: (config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<(<TData = any>(url: string, config?: FetchOptions | undefined) => Promise<import("@strapi/strapi/admin").FetchResponse<TData>>)>>;
+    getUsers: (config?: FetchOptions) => Promise<import("@strapi/strapi/admin").FetchResponse<{
+        (url: string, config: FetchOptions & {
+            responseType: "blob";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<Blob>>;
+        (url: string, config: FetchOptions & {
+            responseType: "text";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<string>>;
+        (url: string, config: FetchOptions & {
+            responseType: "arrayBuffer";
+        }): Promise<import("@strapi/strapi/admin").FetchResponse<ArrayBuffer>>;
+        <TData = unknown>(url: string, config?: FetchOptions | undefined): Promise<import("@strapi/strapi/admin").FetchResponse<TData>>;
+    }>>;
 };
 export { useUsers };

package/dist/admin/src/pages/ImageStudio.d.ts

@@ -0,0 +1,3 @@
+/** Estudio de imágenes: Generador, Plantillas e Imágenes y documentos. */
+declare const ImageStudio: () => import("react/jsx-runtime").JSX.Element;
+export { ImageStudio };

package/dist/admin/src/pages/StudioApp.d.ts

@@ -0,0 +1,3 @@
+/** Entrada «Estudio de imágenes» del menú principal (S4.10): la página ocupa todo el ancho. */
+declare const StudioApp: () => import("react/jsx-runtime").JSX.Element;
+export { StudioApp };

package/dist/admin/src/pluginId.d.ts

@@ -1 +1,7 @@
 export declare const PLUGIN_ID = "strapi-content-generator-gemini";
+/**
+ * Ruta del Estudio de imágenes en el menú principal (S4.10). Es hermana de la del plugin, no
+ * anidada: el menú de Strapi marca activo el prefijo por segmentos, y `plugins/<id>/image-studio`
+ * encendería también «Generador de contenido».
+ */
+export declare const STUDIO_PATH = "plugins/strapi-content-generator-gemini-studio";

package/dist/admin/src/test-setup.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/vitest';

package/dist/admin/src/test-utils.d.ts

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+import type { RenderOptions } from '@testing-library/react';
+declare const render: (ui: ReactElement, options?: RenderOptions) => import("@testing-library/react").RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>;
+export * from '@testing-library/react';
+export { render };