@lyads/visual-editor 0.0.0-stage → 1.0.1

package/dist/vue/services/image-requests.d.ts

@@ -0,0 +1,80 @@
+import type { ShallowRef } from 'vue';
+import type { CanvasPlacement } from '../../core/canvas-layout';
+import type { DocumentKind, SourceInput } from '../../core/document';
+import type { EditorController } from '../controller';
+/** What the person chose: a URL the host is responsible for, and optionally its asset id. */
+export interface EditorImageChoice {
+    /** Identifier of the asset in the host, 1 to 128 of `A-Z a-z 0-9 _ -`. Omit for a plain URL. */
+    readonly id?: string;
+    readonly url: string;
+    readonly alt?: string;
+}
+export interface EditorImageRequest {
+    /** The image being replaced; absent when a new image is being inserted. */
+    readonly nodeId?: string;
+    readonly kind: DocumentKind;
+    readonly current?: {
+        readonly url: string;
+        readonly alt: string;
+    };
+}
+/**
+ * The door a host implements to choose images. The editor knows nothing about the library, the
+ * upload or the permissions behind it: it asks, waits and applies what comes back. Resolving
+ * `undefined` means the person gave up.
+ */
+export interface EditorImagePicker {
+    pickImage(request: EditorImageRequest): Promise<EditorImageChoice | undefined>;
+    /** Declares support for files dropped on the piece; without it, drops are ignored. */
+    uploadImage?(file: File, request: EditorImageRequest): Promise<EditorImageChoice | undefined>;
+}
+export interface ImageRequestPorts {
+    controller(): EditorController;
+    picker(): EditorImagePicker | undefined;
+    /** The older contract: the host is told and later calls `controller.attachAsset` itself. */
+    legacyRequest(): ((nodeId: string | undefined) => void) | undefined;
+    flush(): Promise<boolean>;
+    notify(outcome: 'applied' | 'invalid'): void;
+    /** The exported source with one element rewritten, for a change which is one history step. */
+    replaceElementSource?(id: string, html: string): SourceInput | undefined;
+}
+export interface ImageDialogState {
+    readonly nodeId?: string;
+    readonly url: string;
+    readonly alt: string;
+}
+export type ImageDestination = {
+    readonly targetId: string;
+    readonly placement: CanvasPlacement;
+} | 'end' | undefined;
+/**
+ * One path for every way of choosing an image: the button of the piece, the double click, the
+ * panel, the menu and a dropped file. It prefers the picker of the host, falls back to the older
+ * request event and, without either, to the editor's own dialog with a URL.
+ */
+export declare class ImageRequestService {
+    private readonly ports;
+    /** Open while the editor's own dialog is the way to choose. */
+    readonly dialog: ShallowRef<ImageDialogState | undefined>;
+    readonly busy: ShallowRef<boolean, boolean>;
+    constructor(ports: ImageRequestPorts);
+    get acceptsFiles(): boolean;
+    private request;
+    /** Replaces the image of `nodeId`, or inserts a new one when there is none. */
+    choose(nodeId?: string): Promise<boolean>;
+    /**
+     * A file dropped on the piece goes through the upload the host declared: a new image at
+     * `destination`, or, with `{ replace }`, in place of the image dropped on.
+     */
+    upload(file: File, destination: ImageDestination | {
+        readonly replace: string;
+    }): Promise<boolean>;
+    private settle;
+    /** Applies a choice through the same validated commands as any other change. */
+    apply(choice: EditorImageChoice, nodeId?: string, destination?: ImageDestination): boolean;
+    /** A plain URL has no asset behind it: the image is ordinary markup, validated as any other. */
+    private insertByUrl;
+    /** A plain URL has no asset behind it: only the address and the description change. */
+    private replaceByUrl;
+    cancel(): void;
+}

package/dist/vue/services/live-change.d.ts

@@ -0,0 +1,26 @@
+import type { EditorController } from '../controller';
+/**
+ * Makes a run of changes to one field a single history step. The session has no grouping, so the
+ * previous step of the same run is undone before the next value is applied: the history then
+ * holds the state before the run and its latest value, and nothing in between. The session stays
+ * the only source of truth; no value lives outside it.
+ */
+export declare class LiveChangeGroup {
+    #private;
+    private readonly controller;
+    constructor(controller: () => EditorController);
+    /** Ends the run: the next change of any field is a step of its own. */
+    close(): void;
+    apply(key: string, change: () => boolean): boolean;
+}
+/** Runs the latest call after a pause; `flush` runs it now, as when a field loses the focus. */
+export declare class Debouncer {
+    #private;
+    private readonly delay;
+    constructor(delay?: number);
+    /** A call is waiting for its pause. */
+    get pending(): boolean;
+    schedule(action: () => void): void;
+    flush(): void;
+    cancel(): void;
+}

package/dist/vue/services/property-commands.d.ts

@@ -0,0 +1,28 @@
+import type { DocumentStyleProperty, ImageSizeSettings } from '../../application/document-presentation';
+import type { ImageLinkOptions } from '../../application/image-link';
+import type { SectionLayoutPatch } from '../../core/section-layout';
+import type { EditorController } from '../controller';
+/**
+ * The single door for changing what a block or the document says and looks like: the fields of
+ * the properties panel, the document settings and the text typed in the panel or reviewed after
+ * a recovery. Components decide when a change is one history step (`LiveChangeGroup`) and where
+ * its error is shown; what reaches the controller passes here.
+ */
+export declare class PropertyCommandService {
+    private readonly controller;
+    constructor(controller: () => EditorController);
+    style(property: string, value: string): boolean;
+    attribute(name: string, value: string): boolean;
+    imageLink(href: string, options?: ImageLinkOptions): boolean;
+    imageSize(settings: ImageSizeSettings): boolean;
+    /** The columns of a section; the answer belongs to the editor which was asked. */
+    layout(patch: SectionLayoutPatch): Promise<boolean>;
+    documentStyle(property: DocumentStyleProperty, value: string): boolean;
+    title(value: string): boolean;
+    preheader(value: string): boolean;
+    /** Opens the text of a block for the editor of the panel. */
+    beginText(id: string): boolean;
+    draftText(html: string): boolean;
+    commitText(): boolean;
+    cancelText(): void;
+}

package/dist/vue/services/saved-blocks.d.ts

@@ -0,0 +1,32 @@
+import type { Block } from '../../core/block-document';
+import type { DocumentKind } from '../../core/document';
+/** A block saved to use again: a section with its columns, or one content block. */
+export interface EditorSavedBlock {
+    /** Identifier in the host, 1 to 128 of `A-Z a-z 0-9 _ -`. */
+    readonly id: string;
+    readonly name: string;
+    readonly kind: DocumentKind;
+    /** The block as it was saved; the editor checks it again before it enters a piece. */
+    readonly block: Block;
+}
+export interface EditorSavedBlockInput {
+    readonly name: string;
+    readonly kind: DocumentKind;
+    readonly block: Block;
+}
+/**
+ * The door a host implements to keep saved blocks (per account, team or project, as the host decides): the editor lists them in the
+ * palette, saves the selected block under a name and removes one. Where they are stored, who
+ * may see or change them and the audit belong to the host.
+ */
+export interface EditorSavedBlocks {
+    list(kind: DocumentKind): Promise<readonly EditorSavedBlock[]>;
+    save(input: EditorSavedBlockInput): Promise<EditorSavedBlock>;
+    remove?(id: string): Promise<void>;
+}
+export declare const SAVED_BLOCK_LIMITS: Readonly<{
+    name: 80;
+    list: 200;
+}>;
+/** What the editor keeps of a list from the host: well-formed entries of the kind, in order. */
+export declare function acceptedSavedBlocks(entries: unknown, kind: DocumentKind): readonly EditorSavedBlock[];

package/dist/vue/services/selection-path.d.ts

@@ -0,0 +1,20 @@
+export interface PathEntry {
+    readonly id: string;
+    readonly label: string;
+    readonly icon: string;
+}
+export interface CollapsedPath {
+    readonly head: readonly PathEntry[];
+    /** Levels folded into the ellipsis menu, outermost first. */
+    readonly hidden: readonly PathEntry[];
+    readonly tail: readonly PathEntry[];
+}
+/**
+ * Fits the path of the selection in one line: the outermost level and the innermost ones stay,
+ * the middle folds into one menu. It never asks for a scroll bar.
+ */
+export declare class SelectionPath {
+    collapse(entries: readonly PathEntry[], visible: number): CollapsedPath;
+    /** How many levels fit in `width` pixels, from an average width per level. */
+    capacity(width: number, perLevel?: number): number;
+}

package/dist/vue/services/shortcuts.d.ts

@@ -0,0 +1,39 @@
+import type { EditorShortcutCommand } from '../../canvas-runtime/shared/shortcuts';
+export interface ShortcutPorts {
+    readOnly(): boolean;
+    mode(): 'visual' | 'html';
+    /** A text is being edited in the piece or a gesture is in course: block keys stay out. */
+    busy(): boolean;
+    hasSelection(): boolean;
+    history(direction: 'undo' | 'redo'): void;
+    save(): void;
+    /** There is a change to save, or a text open in the piece which may hold one. */
+    unsaved(): boolean;
+    block(command: 'remove' | 'duplicate' | 'moveUp' | 'moveDown' | 'selectParent'): void;
+    /** Opens the block picker next to the selected block. */
+    insert(): void;
+}
+export interface ShortcutHelp {
+    readonly command: EditorShortcutCommand;
+    readonly labelKey: string;
+    readonly keys: readonly (readonly string[])[];
+}
+/**
+ * The shortcuts of the whole shell, in one place. A key pressed in a panel, in a bar or in the
+ * piece runs the same command; inside a text field of the shell the field keeps its own keys.
+ */
+export declare class ShortcutService {
+    private readonly ports;
+    constructor(ports: ShortcutPorts);
+    list(): readonly ShortcutHelp[];
+    static isTextField(target: EventTarget | null): boolean;
+    /** Handles a key pressed in the shell. Returns whether a command took it. */
+    handle(event: KeyboardEvent): boolean;
+    /**
+     * A key forwarded by the frame of the piece. The frame is not trusted to decide when the host
+     * saves: with nothing to save the request is dropped here.
+     */
+    forwarded(command: EditorShortcutCommand): boolean;
+    /** Runs a command by name. */
+    run(command: EditorShortcutCommand): boolean;
+}

package/dist/vue/services/structure-tree.d.ts

@@ -0,0 +1,38 @@
+import type { CanvasMovementTarget, CanvasPlacement, CanvasRegion } from '../../core/canvas-layout';
+export interface StructureNode {
+    readonly id: string;
+    readonly label: string;
+    readonly detail: string;
+    readonly icon: string;
+    readonly container: boolean;
+    readonly depth: number;
+    readonly children?: StructureNode[];
+}
+export interface StructureEntry {
+    readonly id: string;
+    readonly label: string;
+    readonly labelKey?: string;
+}
+/**
+ * The real hierarchy of selectable blocks. Regions arrive in document order with their depth, so
+ * the tree is built in one pass, whatever plain markup lies between a block and its parent.
+ */
+export declare class StructureTree {
+    private readonly text;
+    private readonly presentation;
+    constructor(text: (key: string) => string);
+    build(regions: readonly CanvasRegion[], entries: readonly StructureEntry[]): StructureNode[];
+    private prune;
+    /** Every ancestor of `id`, outermost first. */
+    path(nodes: readonly StructureNode[], id: string): string[];
+    private trail;
+    find(nodes: readonly StructureNode[], id: string): StructureNode | undefined;
+    count(nodes: readonly StructureNode[]): number;
+    /** Shallow levels start open; deep ones stay folded so a long piece remains readable. */
+    defaultExpanded(nodes: readonly StructureNode[], depth?: number): string[];
+    /**
+     * Where a dragged row would land on the row under the pointer. `ratio` is the vertical position
+     * inside that row; only placements the document accepts are returned.
+     */
+    placement(targets: readonly CanvasMovementTarget[], targetId: string, ratio: number, container: boolean): CanvasPlacement | undefined;
+}

package/dist/vue/services/template-application.d.ts

@@ -0,0 +1,33 @@
+import type { ShallowRef } from 'vue';
+import type { EditorController } from '../controller';
+export interface TemplateChoice {
+    readonly id: string;
+    readonly html: string;
+    readonly trigger: HTMLElement;
+}
+interface PendingTemplate extends TemplateChoice {
+    readonly owner: EditorController;
+    readonly documentId: string;
+    readonly revision: number;
+    readonly editGeneration: number;
+}
+export interface TemplatePorts {
+    controller(): EditorController;
+    prepare(action: () => Promise<boolean>): Promise<void>;
+    invalid(): void;
+}
+/**
+ * Replacing the piece with a model, after the person confirmed it. It works from either mode:
+ * from the HTML mode the pending source is left behind and the editor returns to the visual
+ * mode, since the model replaces everything anyway.
+ */
+export declare class TemplateApplication {
+    private readonly ports;
+    readonly pending: ShallowRef<PendingTemplate | undefined>;
+    constructor(ports: TemplatePorts);
+    choose(choice: TemplateChoice): void;
+    close(): void;
+    /** Applies the confirmed model; returns the element which should receive the focus back. */
+    apply(): Promise<HTMLElement | undefined>;
+}
+export {};

package/dist/vue/services/tree-drag.d.ts

@@ -0,0 +1,28 @@
+import type { CanvasPlacement } from '../../core/canvas-layout';
+export interface TreeDrop {
+    readonly source: string;
+    readonly target: string;
+    readonly placement: CanvasPlacement;
+}
+interface PointerLike {
+    readonly pointerId: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly button: number;
+    readonly isPrimary: boolean;
+}
+/** Pointer transaction of a row dragged in the tree. The document changes only after a drop. */
+export declare class TreeDragSession {
+    #private;
+    get sourceId(): string | undefined;
+    get dragging(): boolean;
+    start(id: string, event: PointerLike): boolean;
+    /** Returns whether the gesture is a drag; a target only counts while it is one. */
+    update(event: PointerLike, target?: {
+        id: string;
+        placement: CanvasPlacement;
+    }): boolean;
+    finish(event: PointerLike): TreeDrop | undefined;
+    cancel(): void;
+}
+export {};

package/dist/vue/session/blocks.d.ts

@@ -0,0 +1,44 @@
+import type { AssetReference } from '../../application/host';
+import type { EditorSession } from '../../application/session';
+import type { CanvasLayout, CanvasPlacement } from '../../core/canvas-layout';
+import type { SourceInput } from '../../core/document';
+import type { TemplateCatalog } from '../../templates/catalog';
+import type { MutationGuard } from './guard';
+/** Commands which add, move, duplicate and remove blocks, each one validated by the session. */
+export declare class BlockEditing {
+    private readonly session;
+    private readonly layout;
+    private readonly templates;
+    private readonly guard;
+    constructor(session: EditorSession, layout: CanvasLayout, templates: TemplateCatalog, guard: MutationGuard);
+    /**
+     * Where something new lands: next to `targetId`, at the selected block, or (`end`) after all
+     * the content whatever is selected.
+     */
+    private destination;
+    /** A block of the catalog, compiled when it is of an e-mail, where `destination` says. */
+    add(type: string, targetId: string | undefined, placement: CanvasPlacement, end?: boolean): Promise<boolean>;
+    /** Markup next to a block, at the selection or at the end: the paste of a copied block. */
+    insertSource(source: SourceInput, targetId: string | undefined, placement: CanvasPlacement, end?: boolean): boolean;
+    /** Replaces the whole source through the ordinary import: one validated history step. */
+    replaceSource(source: SourceInput): boolean;
+    applyTemplate(id: string): Promise<boolean>;
+    moveTo(sourceId: string, targetId: string, placement: CanvasPlacement): boolean;
+    act(id: string, action: 'duplicate' | 'remove' | 'up' | 'down'): boolean;
+    /**
+     * One step of a block up or down, by keyboard or by the buttons of the bar. Next to a sibling
+     * it passes it, entering it first when the sibling is a container which takes the block; at
+     * the edge of its container it leaves it, before or after the closest ancestor which takes it,
+     * or, where that is refused, into the container beside that ancestor.
+     * Every candidate goes through the same check as a drop, so the step lands only where a drag
+     * could, and it is one move of the session: one step of undo.
+     */
+    private step;
+    /**
+     * Where a block enters a container it moves into: the near edge of its deepest container
+     * first (the top going down, the end going up), then each shallower level.
+     */
+    private entry;
+    connectFormReference(reference: string, nodeId?: string): boolean;
+    attachAsset(asset: AssetReference, nodeId?: string): boolean;
+}

package/dist/vue/session/guard.d.ts

@@ -0,0 +1,13 @@
+import type { EditorSession } from '../../application/session';
+type ViewState = ReturnType<EditorSession['getState']>;
+/** What has to be settled before a command changes or exports the document. */
+export declare class MutationGuard {
+    private readonly session;
+    constructor(session: EditorSession);
+    /** Concludes the text being edited and the pending source; false when the document is locked. */
+    prepareMutation(): boolean;
+    prepareExport(): void;
+    /** Nothing changed since `initial`: the answer to something asynchronous still applies. */
+    isCurrent(initial: ViewState): boolean;
+}
+export {};

package/dist/vue/session/structure.d.ts

@@ -0,0 +1,36 @@
+import type { EditorSession } from '../../application/session';
+import type { BlockCatalog, BlockType } from '../../core/catalog';
+import type { CanvasLayout, CanvasMovementTarget } from '../../core/canvas-layout';
+import type { DocumentOutline, OutlineEntry } from '../outline';
+export interface PropertyCapabilities {
+    attributes: readonly string[];
+    styles: readonly string[];
+    richText: boolean;
+    blocks: boolean;
+    container: boolean;
+    kind: BlockType | 'container' | 'native';
+}
+/**
+ * What the shell asks about the structure of the document on screen: its blocks, the selected
+ * one, where a block may go. Answers which cost a walk of the tree are kept for the revision
+ * which produced them; a revision number never names two different documents.
+ */
+export declare class StructureQueries {
+    #private;
+    private readonly session;
+    private readonly layout;
+    private readonly catalog;
+    private readonly outline;
+    constructor(session: EditorSession, layout: CanvasLayout, catalog: BlockCatalog, outline: DocumentOutline);
+    private same;
+    entries(): readonly OutlineEntry[];
+    regions(): readonly import("../../core/canvas-layout").CanvasRegion[];
+    resolve(id: string): import("../../core/canvas-layout").CanvasRegion | undefined;
+    selected(): OutlineEntry | undefined;
+    /** The closest selectable block which contains `id`. */
+    parentOf(id: string): string | undefined;
+    movementTargets(sourceId: string): readonly CanvasMovementTarget[];
+    /** Where a new block may be dropped, by block and side; the command validates again. */
+    insertionTargets(): readonly CanvasMovementTarget[];
+    propertyCapabilities(): PropertyCapabilities | undefined;
+}

package/dist/vue/session/text.d.ts

@@ -0,0 +1,23 @@
+import type { EditorSession } from '../../application/session';
+import type { BlockCatalog } from '../../core/catalog';
+import type { CanvasLayout } from '../../core/canvas-layout';
+import type { DocumentOutline } from '../outline';
+import type { StructureQueries } from './structure';
+/** The text of a block: what the editors show and the transaction which changes it. */
+export declare class TextEditing {
+    private readonly session;
+    private readonly layout;
+    private readonly catalog;
+    private readonly outline;
+    private readonly structure;
+    constructor(session: EditorSession, layout: CanvasLayout, catalog: BlockCatalog, outline: DocumentOutline, structure: StructureQueries);
+    private region;
+    plain(): string;
+    /** The projection of the text of `id`: the valid pending draft, or what the document holds. */
+    richTextFor(id: string): string | undefined;
+    allowsBlocksFor(id: string): boolean;
+    /** Opens the transaction of an already selected block. */
+    begin(id: string): boolean;
+    updatePlain(value: string): boolean;
+    updateRichTextFor(id: string, value: string): boolean;
+}

package/dist/vue/session/transfer.d.ts

@@ -0,0 +1,23 @@
+import type { EditorSession } from '../../application/session';
+import type { CanvasLayout } from '../../core/canvas-layout';
+import type { SourceInput } from '../../core/document';
+import type { HtmlAssemblyPort } from '../../renderers/preview-document';
+import type { DocumentOutline } from '../outline';
+import type { MutationGuard } from './guard';
+/** What leaves and enters the editor as a file: source, document, preview and recovery copy. */
+export declare class DocumentTransfer {
+    private readonly session;
+    private readonly assembler;
+    private readonly layout;
+    private readonly outline;
+    private readonly guard;
+    constructor(session: EditorSession, assembler: HtmlAssemblyPort, layout: CanvasLayout, outline: DocumentOutline, guard: MutationGuard);
+    exportSource(): SourceInput;
+    exportHtml(): string;
+    previewHtml(): string;
+    exportJson(): string;
+    exportRecovery(): string;
+    importFile(file: File): Promise<boolean>;
+    importRecovery(value: unknown): boolean;
+    private restore;
+}

package/dist/vue/theme.d.ts

@@ -0,0 +1,20 @@
+export interface EditorThemeOptions {
+    readonly accent?: string;
+    readonly surface?: string;
+    readonly background?: string;
+    readonly text?: string;
+    readonly muted?: string;
+    readonly border?: string;
+    readonly radius?: number;
+    readonly fontFamily?: string;
+}
+/**
+ * Optional overrides for a host which is not themed by Nuxt UI variables. The editor has no brand
+ * of its own: without options it defines nothing and inherits the theme of the host. Each option
+ * given sets the matching theme variable for this editor only.
+ */
+export declare class EditorTheme {
+    private readonly tokens;
+    constructor(options?: EditorThemeOptions);
+    variables(): Readonly<Record<string, string>>;
+}

package/dist/vue/variables.d.ts

@@ -0,0 +1,21 @@
+/** A value the host fills in when the piece is sent or published: a name, a link, a date. */
+export interface EditorVariable {
+    readonly key: string;
+    readonly label: string;
+    readonly purpose: 'text' | 'url';
+    /** Optional heading under which the variable is listed: "Contato", "Empresa". */
+    readonly group?: string;
+}
+export interface VariableGroup {
+    readonly label: string;
+    readonly variables: readonly EditorVariable[];
+}
+/** Groups the catalog of the host for one purpose and resolves a key to its token. */
+export declare class VariableCatalog {
+    private readonly variables;
+    constructor(variables: readonly EditorVariable[]);
+    for(purpose: 'text' | 'url'): readonly EditorVariable[];
+    groups(purpose: 'text' | 'url', fallback: string): readonly VariableGroup[];
+    /** The text which stands for the variable in the piece, or undefined for an unknown key. */
+    token(key: string, purpose: 'text' | 'url'): string | undefined;
+}

package/dist/vue/workbench.d.ts

@@ -0,0 +1,100 @@
+import type { ComputedRef, InjectionKey, Ref, ShallowRef } from 'vue';
+import type { EditorDocumentData, SourceInput } from '../core/document';
+import type { SelectionPreviewRenderer } from '../renderers/selection-preview';
+import type { CanvasTextStyle } from '../security/text-presentation';
+import type { EditorController, EditorViewState } from './controller';
+import { EditorLocale } from './locale';
+import type { EditorMessages } from './locale';
+import { BlockCommandService } from './services/block-commands';
+import { ImageRequestService } from './services/image-requests';
+import type { EditorImagePicker } from './services/image-requests';
+import { LiveChangeGroup } from './services/live-change';
+import { PropertyCommandService } from './services/property-commands';
+import { ShortcutService } from './services/shortcuts';
+import { TemplateApplication } from './services/template-application';
+import type { EditorVariable } from './variables';
+/** What the editing area offers to the rest of the shell while it is mounted. */
+export interface CanvasApi {
+    flush(): Promise<boolean>;
+    cancel(): void;
+    edit(id: string): void;
+    editingId(): string | undefined;
+    /** A drag from the palette or of a file is in course. */
+    gesture(): boolean;
+    canHistory(direction: 'undo' | 'redo'): boolean;
+    history(direction: 'undo' | 'redo'): boolean;
+    insertText(value: string): boolean;
+    hover(id: string | undefined): void;
+    startPalette(type: string, event: PointerEvent): void;
+    paletteDragged(): boolean;
+}
+/** The second text editor, in the properties panel, shares history and variables with the shell. */
+export interface PanelTextApi {
+    canHistory(direction: 'undo' | 'redo'): boolean;
+    history(direction: 'undo' | 'redo'): boolean;
+    insertText(value: string): boolean;
+}
+export interface EffectiveText {
+    readonly documentId: string;
+    readonly revision: number;
+    readonly targetId: string;
+    readonly style: CanvasTextStyle;
+}
+export type PreviewWidth = 'desktop' | 'tablet' | 'mobile';
+export interface WorkbenchOptions {
+    controller(): EditorController;
+    renderer(): SelectionPreviewRenderer | undefined;
+    messages(): EditorMessages | undefined;
+    variables(): readonly EditorVariable[];
+    imagePicker(): EditorImagePicker | undefined;
+    /** The older image contract, when the host enabled it. */
+    requestImage(): ((nodeId: string | undefined) => void) | undefined;
+    saved(payload: {
+        document: EditorDocumentData;
+        source: SourceInput;
+    }): void;
+    failed(code: string): void;
+}
+/**
+ * Everything one mounted editor shares between its components: the state of its session and the
+ * services which act on it. One per editor; nothing here is global.
+ */
+export interface EditorWorkbench {
+    readonly state: ShallowRef<EditorViewState>;
+    readonly locale: ComputedRef<EditorLocale>;
+    readonly feedback: Ref<string>;
+    readonly busy: Ref<boolean>;
+    readonly width: Ref<PreviewWidth>;
+    readonly canvas: ShallowRef<CanvasApi | undefined>;
+    readonly panelText: ShallowRef<PanelTextApi | undefined>;
+    readonly inlineEditingId: Ref<string | undefined>;
+    readonly effectiveText: ShallowRef<EffectiveText | undefined>;
+    readonly commands: BlockCommandService;
+    readonly properties: PropertyCommandService;
+    readonly images: ImageRequestService;
+    readonly shortcuts: ShortcutService;
+    readonly live: LiveChangeGroup;
+    readonly templates: TemplateApplication;
+    controller(): EditorController;
+    renderer(): SelectionPreviewRenderer | undefined;
+    variables(): readonly EditorVariable[];
+    t(key: string): string;
+    /** Concludes a text being edited in the piece before anything else acts on the document. */
+    flush(): Promise<boolean>;
+    act(action: () => boolean | void | Promise<boolean | void>, success?: string): Promise<void>;
+    prepare(action: () => Promise<boolean>): Promise<void>;
+    select(id: string): Promise<void>;
+    history(direction: 'undo' | 'redo'): void;
+    /** A step of the document itself, when the text being edited has none of its own left. */
+    documentHistory(direction: 'undo' | 'redo', success?: string): void;
+    canHistory(direction: 'undo' | 'redo'): boolean;
+    setMode(mode: 'visual' | 'html'): Promise<void>;
+    save(): Promise<void>;
+    insertVariable(key: string): boolean;
+    report(code: string): void;
+    dispose(): void;
+}
+declare const WORKBENCH: InjectionKey<EditorWorkbench>;
+export { WORKBENCH };
+export declare function useWorkbench(): EditorWorkbench;
+export declare function createWorkbench(options: WorkbenchOptions): EditorWorkbench;