@unlayer/types 1.516.0 → 1.519.0

package/dist/editor/editor.d.ts

@@ -326,8 +326,116 @@ interface Config {
         defaultErrors: Audit[];
     }) => Audit[] | Promise<Audit[]>;
     tabs?: Tabs;
+    /**
+     * Lets AI agents operating the page (browser agents, automation scripts)
+     * find this editor through `unlayer.agent` and edit its design JSON instead
+     * of driving the drag-and-drop UI. Once the editor confirms it supports
+     * this (older pinned or stable versions don't), appends a short pointer to
+     * the editor iframe's accessible name; nothing changes on screen. Set to
+     * `false` to leave this editor out of `unlayer.agent`. Defaults to `true`.
+     */
+    agentApi?: boolean;
+}
+
+export interface AgentTarget {
+    /** Index into `describe().editors`. Defaults to the first editor. */
+    editor?: number;
+}
+
+export interface AgentDesignIssue {
+    path: string;
+    message: string;
+    code: string;
+}
+
+export interface AgentLoadDesignResult {
+    /** True when the design passed validation and was loaded. */
+    ok: boolean;
+    loaded: boolean;
+    errors: AgentDesignIssue[];
+    errorCount: number;
+    /**
+     * Ids of elements the template protects (locked, or not editable,
+     * deletable, or movable) that the design tried to change. They keep their
+     * current content; everything else was applied.
+     */
+    protectedElements?: string[];
+    /** The editor's quality checks on the loaded design; null if they couldn't run. */
+    audit?: {
+        status: 'PASS' | 'FAIL';
+        issues: Array<{
+            severity: 'ERROR' | 'WARNING';
+            title: string;
+            description: string;
+            elementId?: string;
+        }>;
+        issueCount: number;
+    } | null;
+}
+
+export interface AgentEditorSummary {
+    index: number;
+    containerId: string | null;
+    version: string | undefined;
 }
 
+export interface AgentDescription {
+    /** Markdown instructions for the agent. Read this first. */
+    guide: string;
+    editors: AgentEditorSummary[];
+    editor: number;
+    displayMode: string;
+    designMode: string | null;
+    schemaVersion: number;
+    contentTypes: string[];
+    customTools: Array<Record<string, unknown> & {
+        slug: string;
+    }>;
+    /** Merge tags to personalize text with, written exactly as `value`. */
+    mergeTags: Array<{
+        name: string;
+        value: string;
+    }>;
+    fonts: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+/**
+ * `unlayer.agent`: a promise-based surface for AI agents operating the page.
+ *
+ * Agents fail at the drag-and-drop UI but write good design JSON once they
+ * know `loadDesign` exists. This gives them one discoverable entry point,
+ * `describe()`, that returns instructions plus this editor's real
+ * capabilities (content types, custom tools, fonts), and a `loadDesign` that
+ * reports schema errors instead of silently loading a broken design.
+ */
+
+export interface AgentApi {
+    /** Instructions and this editor's capabilities. Call this first. */
+    describe(target?: AgentTarget): Promise<AgentDescription>;
+    /** Full JSON Schema of the design this editor accepts, custom tools included. */
+    schema(target?: AgentTarget): Promise<Record<string, unknown>>;
+    getDesign(target?: AgentTarget): Promise<JSONTemplate>;
+    /**
+     * Validates, then loads. On `{ ok: false, loaded: false }` nothing changed;
+     * fix `errors` and retry.
+     */
+    loadDesign(design: JSONTemplate, options?: AgentTarget): Promise<AgentLoadDesignResult>;
+    exportHtml(options?: AgentTarget & ExportHtmlOptions): Promise<ExportHtmlResult>;
+    /**
+     * Opens the editor's preview at a device size, so the agent can check its
+     * work in a screenshot; `null` closes it and puts the canvas back on the
+     * device it was on. Resolves once the change has rendered.
+     */
+    preview(device: AgentPreviewDevice | null, target?: AgentTarget): Promise<void>;
+}
+
+export type AgentPreviewDevice =
+  | 'desktop'
+  | 'tablet'
+  | 'mobile';
+
 type Message = Record<string, any>;
 
 interface MessageData {
@@ -357,6 +465,12 @@ export interface FrameOptions {
      */
     iframeTextColor?: string;
 }
+/** What this frame's editor build says it supports. */
+
+export interface FrameCapabilities {
+    /** Answers `agent:*` messages (`unlayer.agent`). */
+    agentApi: boolean;
+}
 
 declare class Frame {
     id: number;
@@ -367,9 +481,19 @@ declare class Frame {
     callbacks: {
         [key: number]: ((...args: any[]) => any) | undefined;
     };
+    /** Null until the editor announces itself (or the iframe finishes loading). */
+    capabilities: FrameCapabilities | null;
+    private capabilityListeners;
     constructor(src: string, options?: FrameOptions);
     createIframe(src: string, { iframeBackgroundColor, iframeTextColor }?: FrameOptions): HTMLIFrameElement;
     destroy: () => void;
+    /**
+     * Calls `listener` with the editor's capabilities once they are known, and
+     * again if they improve: an `unlayer:ready` that arrives after the load
+     * fallback still turns a capability on. Capabilities never turn off.
+     */
+    onCapabilities(listener: (capabilities: FrameCapabilities) => void): void;
+    private setCapabilities;
     appendTo(el: Element): void;
     onWindowMessage: (event: MessageEvent<any>) => void;
     postMessage(action: string, message: Message): void;
@@ -386,6 +510,9 @@ declare class EditorClass<TClassDisplayMode extends DisplayMode | undefined = un
     frame: Frame | null;
     constructor(config?: Config);
     init(config?: Config): void;
+    /** Container element id, so agents can tell several editors apart. */
+    get agentContainerId(): string | null;
+    private initAgentApi;
     private captureTargetElement;
     destroy(): void;
     versions: {
@@ -513,6 +640,12 @@ declare class EditorClass<TClassDisplayMode extends DisplayMode | undefined = un
 }
 
 declare class Embed extends EditorClass {
+    /**
+     * Entry point for AI agents operating the page: start with
+     * `await unlayer.agent.describe()`. Covers every editor on the page,
+     * including `createEditor()` instances.
+     */
+    agent: AgentApi;
     createEditor<TDisplayMode extends DisplayMode | undefined = undefined>(config: Config): EditorClass<TDisplayMode>;
 }
 

package/dist/editor/export.d.ts

@@ -19,6 +19,12 @@ export interface ExportHtmlOptions {
     live?: boolean;
     mergeTags?: MergeTagsValues;
     minify?: boolean;
+    /**
+     * Include classic Outlook for Windows and legacy IE conditional markup in
+     * email HTML. Defaults to true. False also removes custom HTML conditionals;
+     * AMP HTML and other display modes are unchanged.
+     */
+    outlookSupport?: boolean;
     popupId?: string;
     title?: string;
     validateAmp?: boolean;

package/dist/editor/features.d.ts

@@ -224,7 +224,7 @@ export interface Features {
          * Preferred AI model for the assistant. Accepts:
          *
          * - a `"<provider>/<modelId>"` pair (e.g. `"openai/gpt-5.6-luna"`,
-         *   `"anthropic/claude-opus-5"`) — pins both provider and model,
+         *   `"anthropic/claude-opus-5-5"`) — pins both provider and model,
          *   unambiguous;
          * - a bare model id (e.g. `"gpt-5.6-luna"`);
          * - a provider name (e.g. `"openai"`, `"anthropic"`) — selects the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unlayer/types",
-  "version": "1.516.0",
+  "version": "1.519.0",
   "license": "MIT",
   "private": false,
   "types": "./dist/index.d.ts",