@interware/content-generator 0.4.3 → 0.5.0

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

@@ -0,0 +1,10 @@
+import type { Delta } from './layers';
+import type { Layer, LayerPatch } from './types';
+/** Manija de redimensión que ofrece cada tipo de capa. */
+export type Handle = 'box' | 'width' | 'size';
+export type DragMode = 'move' | Handle;
+export declare const handleFor: (layer: Layer) => Handle | null;
+/** Cambio que produce un arrastre `delta` (px de pantalla) sobre la capa tal como estaba al empezar. */
+export declare const dragPatch: (mode: DragMode, start: Layer, delta: Delta, scale: number, { keepRatio }?: {
+    keepRatio?: boolean;
+}) => LayerPatch;

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

@@ -0,0 +1,58 @@
+import type { Layer, LayerPatch, Template } from './types';
+export declare const HISTORY_LIMIT = 30;
+export interface EditorState {
+    template: Template;
+    layers: Layer[];
+    past: Layer[][];
+    future: Layer[][];
+    /** Capas antes del gesto transitorio en curso (arrastre); `commit` las pasa al historial. */
+    pending: Layer[] | null;
+    selectedId: string | null;
+}
+export type EditorAction = {
+    type: 'select';
+    id: string | null;
+} | {
+    type: 'add';
+    layer: Layer;
+} | {
+    type: 'update';
+    id: string;
+    patch: LayerPatch;
+    transient?: boolean;
+} | {
+    type: 'commit';
+} | {
+    type: 'remove';
+    id: string;
+} | {
+    type: 'reorder';
+    id: string;
+    to: 'front' | 'back' | 'up' | 'down';
+} | {
+    type: 'moveTo';
+    id: string;
+    targetId: string;
+    place: 'above' | 'below';
+} | {
+    type: 'toggleBackground';
+    id: string;
+} | {
+    type: 'undo';
+} | {
+    type: 'redo';
+} | {
+    type: 'reset';
+}
+/** Fuera del historial de deshacer: el historial guarda solo capas (diseño S4.5, D5). */
+ | {
+    type: 'setSafeMargin';
+    value: number;
+}
+/** También fuera del historial: renombrar no se deshace con ⌘Z (S4.11). */
+ | {
+    type: 'rename';
+    name: string;
+};
+export declare const initEditor: (template: Template) => EditorState;
+export declare const editorReducer: (state: EditorState, action: EditorAction) => EditorState;

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

@@ -0,0 +1,42 @@
+import type { ElementPreset } from './presets';
+import type { Layer, LayerType } from './types';
+/** Siguiente nombre libre para una capa del tipo dado: «Etiqueta 1», «Etiqueta 2», … */
+export declare const nextLayerName: (layers: Pick<Layer, 'label'>[], type: LayerType) => string;
+export interface Box {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Caja envolvente aproximada de una capa, en unidades del lienzo. */
+export declare const bbox: (l: Layer) => Box;
+export interface Delta {
+    dx: number;
+    dy: number;
+}
+/** Nueva posición tras arrastrar `delta` píxeles de pantalla con el lienzo a escala `scale`. */
+export declare const moveBy: (pos: {
+    x: number;
+    y: number;
+}, { dx, dy }: Delta, scale: number) => {
+    x: number;
+    y: number;
+};
+/** Nuevo tamaño tras arrastrar la manija inferior derecha. */
+export declare const resizeBy: (size: {
+    w: number;
+    h: number;
+}, { dx, dy }: Delta, scale: number, { min, keepRatio }?: {
+    min?: number;
+    keepRatio?: boolean;
+}) => {
+    w: number;
+    h: number;
+};
+/** Capa nueva a partir de un elemento de la paleta, dentro del margen seguro y a media altura. */
+export declare const createLayerFromPreset: (preset: ElementPreset, layers: Layer[], canvas: {
+    safeMargin: number;
+    height: number;
+}, id: string) => Layer;
+/** `#RRGGBB` → `rgba(r, g, b, a)`. */
+export declare const hexA: (hex: string, alpha: number) => string;

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

@@ -0,0 +1,38 @@
+/**
+ * Paleta InterWare (paleta canónica del brochure). Es la única que ofrecen las muestras del
+ * editor y la única que usan las plantillas base.
+ */
+export declare const PALETTE: readonly [{
+    readonly label: "Navy";
+    readonly value: "#1F2A44";
+}, {
+    readonly label: "Rojo";
+    readonly value: "#E4002B";
+}, {
+    readonly label: "Teal";
+    readonly value: "#00C7B1";
+}, {
+    readonly label: "Teal suave";
+    readonly value: "#92CFC7";
+}, {
+    readonly label: "Amarillo";
+    readonly value: "#FFC844";
+}, {
+    readonly label: "Amarillo suave";
+    readonly value: "#F8DF8D";
+}, {
+    readonly label: "Gris";
+    readonly value: "#5B6473";
+}, {
+    readonly label: "Papel";
+    readonly value: "#EEF1F5";
+}, {
+    readonly label: "Blanco";
+    readonly value: "#FFFFFF";
+}];
+export declare const NAVY = "#1F2A44";
+export declare const RED = "#E4002B";
+export declare const TEAL = "#00C7B1";
+export declare const GREY = "#5B6473";
+export declare const PAPER = "#EEF1F5";
+export declare const WHITE = "#FFFFFF";

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

@@ -0,0 +1,17 @@
+import type { Layer, LayerType, ShapeKind } from './types';
+/** Elemento que se puede agregar desde la paleta del editor. */
+export interface ElementPreset {
+    id: string;
+    label: string;
+    /** Nombre de un ícono de @strapi/icons para la paleta. */
+    icon: string;
+    type: LayerType;
+    props: Partial<Layer> & Record<string, unknown>;
+}
+export declare const ELEMENT_PRESETS: ElementPreset[];
+export declare const SHAPE_TYPES: {
+    id: ShapeKind;
+    label: string;
+}[];
+/** Íconos de @strapi/icons disponibles como contenido de una pieza. */
+export declare const ICON_LIBRARY: readonly ["Star", "Heart", "Lightning", "CheckCircle", "Shield", "Sparkle", "Rocket", "User", "Briefcase", "SealCheck", "Crown", "Lightbulb", "Server", "Globe", "Cloud", "Database", "Cog", "ChartBubble", "ChartPie", "PresentationChart", "Earth", "PinMap", "Mail", "Phone", "Play"];

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

@@ -0,0 +1,19 @@
+/** Comandos de teclado del editor (diseño S4.5, D6). */
+export type Command = 'undo' | 'redo' | 'duplicate' | 'save' | 'deselect' | 'delete' | {
+    reorder: 'front' | 'back' | 'up' | 'down';
+} | {
+    nudge: {
+        dx: number;
+        dy: number;
+    };
+};
+type KeyLike = {
+    key: string;
+    metaKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+};
+export declare const commandFor: (e: KeyLike) => Command | null;
+/** ¿El foco está en un lugar donde se escribe? Ahí los atajos no aplican. */
+export declare const isTyping: (target: EventTarget | null) => boolean;
+export {};

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

@@ -0,0 +1,24 @@
+import type { Box } from './layers';
+import type { Layer } from './types';
+/** Redondea a la unidad de la cuadrícula más cercana (diseño S4.5, D1). */
+export declare const snapValue: (v: number, unit: number) => number;
+/**
+ * Guías inteligentes: alinea el borde o el centro de `box` con el borde o centro más cercano del
+ * lienzo o de otra capa, si está a menos de `tolerance` (unidades del lienzo). Por eje se aplica la
+ * coincidencia más cercana y se devuelve su línea guía.
+ */
+export declare const alignToGuides: (box: Box, others: Box[], canvas: {
+    w: number;
+    h: number;
+}, tolerance: number) => {
+    x: number;
+    y: number;
+    v: number[];
+    h: number[];
+};
+/** Capas visibles (sin contar fondos) que salen del área segura (diseño S4.5, D8). */
+export declare const safeViolations: (layers: Layer[], t: {
+    width: number;
+    height: number;
+    safeMargin: number;
+}) => Layer[];

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

@@ -0,0 +1,8 @@
+import type { Template } from './types';
+/**
+ * Las 6 plantillas base del prototipo, adaptadas a la marca InterWare: paleta del brochure,
+ * Texta para titulares (`font: 'display'`) e Inter para el resto. Viven en código (ADR-004).
+ */
+export declare const BASE_TEMPLATES: Template[];
+/** Id de la plantilla base que representa (original o editada), o `undefined` si no es base (S4.15). */
+export declare const baseIdOf: (t: Template) => string | undefined;

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 `DesignSystemProvider` propio del plugin (S4.10). 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;