@lyads/visual-editor 0.0.0-stage → 1.0.1

package/dist/application/block-placement.d.ts

@@ -0,0 +1,30 @@
+import type { BlockDocument, BlockNodeType, BlockRules, BlockTarget } from '../core/block-document';
+export type BlockPlacement = 'before' | 'after' | 'inside';
+/** Where a block may land next to or inside one other block. */
+export interface BlockPlacementTarget {
+    readonly targetId: string;
+    readonly placements: readonly BlockPlacement[];
+}
+/**
+ * Where a block may go, by the rules of the block types: the drop targets of a drag, of a block
+ * from the palette and the single step of "move up/down". Nothing here changes the piece; the
+ * aggregate checks every command again.
+ */
+export declare class BlockPlacementService {
+    private readonly rules;
+    constructor(rules: BlockRules);
+    /** Targets for an existing block: never inside itself, never leaving a parent too empty. */
+    movementTargets(document: BlockDocument, id: string): readonly BlockPlacementTarget[];
+    /** Targets for a new block of a type. */
+    insertionTargets(document: BlockDocument, type: BlockNodeType): readonly BlockPlacementTarget[];
+    /** The command target of a placement next to or inside a block. */
+    target(targetId: string, placement: BlockPlacement): BlockTarget;
+    /**
+     * One step up or down: past the sibling on that side, or, at the edge of its parent, into the
+     * neighbouring container of the same type (the next column or section).
+     */
+    step(document: BlockDocument, id: string, direction: 'up' | 'down'): BlockTarget | undefined;
+    private targets;
+    private accepts;
+    private locate;
+}

package/dist/application/block-session.d.ts

@@ -0,0 +1,135 @@
+import { BlockDocument } from '../core/block-document';
+import type { Block, BlockDevice, BlockDocumentData, BlockNodeType, BlockProps, BlockTarget, StylePatch } from '../core/block-document';
+import type { Diagnostic, SourceInput } from '../core/document';
+import { DocumentHistory } from '../core/history';
+/** The final output of a piece: the compiled e-mail, or the HTML and CSS of the page. */
+export interface BlockOutputPort {
+    render(document: BlockDocument): Promise<SourceInput>;
+}
+/** Where the host keeps a block piece, with the output generated from it. */
+export interface BlockStorePort {
+    save(document: BlockDocumentData, output: SourceInput, expectedRevision: number, signal?: AbortSignal): Promise<{
+        revision: number;
+    }>;
+}
+/** Creates the blocks of each type and says which keys hold a text edited in place. */
+export interface BlockFactoryPort {
+    create(type: BlockNodeType, nextId: () => string, props?: BlockProps): Block;
+    textKeys(type: BlockNodeType): readonly string[];
+}
+export interface IdentifierPort {
+    next(): string;
+}
+/** An image chosen for a block: the asset of the host, when there is one. */
+export interface BlockImageChoice {
+    readonly url: string;
+    readonly alt?: string;
+    readonly assetId?: string;
+}
+export interface BlockEditorState {
+    readonly document: BlockDocumentData;
+    readonly selectedBlockId: string | undefined;
+    /** The text being edited in place, until it is confirmed or cancelled. */
+    readonly pendingText: {
+        readonly id: string;
+        readonly key: string;
+    } | undefined;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly readOnly: boolean;
+    readonly dirty: boolean;
+    readonly saving: boolean;
+}
+export interface BlockSessionServices {
+    readonly factory: BlockFactoryPort;
+    readonly output: BlockOutputPort;
+    readonly identifiers: IdentifierPort;
+    readonly store?: BlockStorePort;
+    readonly history?: DocumentHistory<BlockDocument>;
+}
+export interface BlockSessionOptions {
+    readonly document: BlockDocument;
+    readonly readOnly?: boolean;
+    readonly persistedRevision?: number;
+    readonly onObserverError?: (error: unknown) => void;
+}
+/**
+ * The editing session of a block piece (schema 2), beside the session of the HTML document
+ * (schema 1). Every command is one step of history; the document is the immutable aggregate,
+ * so a refused command changes nothing. Undoing moves forward in revision, as in schema 1, so a
+ * host saving by compare-and-swap never goes back.
+ */
+export declare class BlockEditorSession {
+    #private;
+    private readonly services;
+    private readonly options;
+    constructor(services: BlockSessionServices, options: BlockSessionOptions);
+    /** The current piece; immutable, so it can be handed to generators as it is. */
+    document(): BlockDocument;
+    snapshot(): BlockDocumentData;
+    getState(): BlockEditorState;
+    subscribe(listener: (state: BlockEditorState) => void): () => void;
+    setReadOnly(value: boolean): void;
+    select(id: string | undefined): boolean;
+    /** A new block of a type; it becomes the selection. Returns its id, or undefined. */
+    insert(type: BlockNodeType, target: BlockTarget, props?: BlockProps): string | undefined;
+    /** A block with its children, made with ids of `newId()`; it becomes the selection. */
+    insertBlock(block: Block, target: BlockTarget): string | undefined;
+    /** A new block id, unique in practice: 80 random bits. */
+    newId(): string;
+    move(id: string, target: BlockTarget): boolean;
+    duplicate(id: string): boolean;
+    remove(id: string): boolean;
+    /**
+     * Properties of a block in one step. A new address typed by hand (`url` without `assetId`)
+     * no longer points at the asset of the host library chosen before: that asset goes in the
+     * same step, so the host never keeps a stale reference.
+     */
+    updateProps(id: string, patch: BlockProps, device?: BlockDevice): boolean;
+    restoreDefault(id: string, keys: readonly string[], device?: BlockDevice): boolean;
+    /**
+     * Address, description and asset of an image in one step of history. What the choice does
+     * not bring goes: the description and the asset of the previous image never describe the new
+     * one.
+     */
+    replaceImage(id: string, choice: BlockImageChoice): boolean;
+    updateStyles(patch: StylePatch): boolean;
+    restoreStyleDefault(group?: string, keys?: readonly string[]): boolean;
+    setLanguage(lang: string): boolean;
+    setTitle(title: string): boolean;
+    /** A whole piece of the same kind and id, e.g. made from a template: one step of history. */
+    replace(document: BlockDocument): boolean;
+    /** Opens the text of a block for editing in place. */
+    beginText(id: string): boolean;
+    updateTextDraft(html: string): boolean;
+    /**
+     * Confirms the text being edited: the block takes it in the projection of its type. A refused
+     * text stays open as it was typed, with the diagnostic, as in the HTML document: nothing the
+     * person wrote is lost because the piece did not accept it.
+     */
+    commitText(): boolean;
+    cancelText(): void;
+    undo(): boolean;
+    redo(): boolean;
+    /** Generates the final output and hands both to the host store. */
+    save(): Promise<boolean>;
+    /**
+     * As `save`, returning the exact piece the store received (changes made while it was being
+     * saved are not in it), or undefined when nothing was saved.
+     */
+    saveDocument(): Promise<BlockDocumentData | undefined>;
+    dispose(): void;
+    private change;
+    /** The piece a command makes, or undefined (with the diagnostic) when it is refused. */
+    private attempt;
+    private apply;
+    private restore;
+    private commit;
+    private textChanged;
+    private fail;
+    private canWrite;
+    private assertActive;
+    private emit;
+    private deliver;
+}

package/dist/application/content-service.d.ts

@@ -0,0 +1,73 @@
+import { EditorDocument } from '../core/document';
+import type { RichTextDecorationLine } from '../core/rich-text-format';
+import type { Diagnostic, DocumentKind, DocumentNode, EditorDocumentData, ImportResult, SourceInput } from '../core/document';
+export interface CodecPort {
+    import(source: SourceInput, kind: DocumentKind, previous?: EditorDocumentData): ImportResult;
+    export(document: EditorDocumentData | EditorDocument): SourceInput;
+    /** Auxiliary parse which must not replace the preserved source of an edited document. */
+    inspect?(source: SourceInput, kind: DocumentKind): ImportResult;
+}
+export interface PolicyPort {
+    validate(document: EditorDocumentData | EditorDocument): readonly Diagnostic[];
+    assertSafe(document: EditorDocumentData | EditorDocument): void;
+    /** Whether editor commands may write these nodes; stricter than what an import keeps. */
+    writable?(nodes: readonly DocumentNode[]): boolean;
+    /** Applies the removals of the document kind and says, grouped, what was removed. */
+    sanitize?(document: EditorDocumentData | EditorDocument): AdmittedDocumentData;
+}
+export interface AdmittedDocumentData {
+    readonly document: EditorDocumentData;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface AdmittedDocument {
+    readonly document: EditorDocument;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface InlineStylePort {
+    setDeclaration(css: string, property: string, value: string): string;
+    readDeclarations?(css: string): Readonly<Record<string, string>>;
+    removeDeclarations?(css: string, properties: readonly string[]): string;
+    prependDefaults(existing: string, incoming: readonly string[]): string;
+    richTextStyles?(css: string): Readonly<Record<string, string>> | undefined;
+    removeDecoration?(css: string, line: RichTextDecorationLine): string;
+    hasDecorationRules?(css: string): boolean;
+}
+export declare class ContentService {
+    private readonly codec;
+    private readonly policy;
+    private readonly styles;
+    constructor(codec: CodecPort, policy: PolicyPort, styles: InlineStylePort);
+    import(source: SourceInput, kind: DocumentKind, previous?: EditorDocumentData): ImportResult;
+    /** Imports a snippet or projection which never becomes the session document by itself. */
+    inspect(source: SourceInput, kind: DocumentKind): ImportResult;
+    validate(document: EditorDocumentData | EditorDocument): readonly Diagnostic[];
+    setStyle(css: string, property: string, value: string): string;
+    withoutStyles(css: string, properties: readonly string[]): string;
+    inlineDeclarations(css: string): Readonly<Record<string, string>>;
+    richTextStyles(css: string): Readonly<Record<string, string>> | undefined;
+    removeDecoration(css: string, line: RichTextDecorationLine): string;
+    hasDecorationRules(css: string): boolean;
+    mergeRichTextStyle(existing: string, incoming: string): string;
+    addDefaultStyles(css: string, incoming: readonly string[]): string;
+    /**
+     * Entry of a document which did not come from this session: host JSON, a file, a backup.
+     * It follows the same rules as imported source. An e-mail which still carries scripts,
+     * embeds, handlers or code URLs has them removed and reported, never silently accepted.
+     */
+    admit(input: unknown): AdmittedDocument;
+    /**
+     * Markup produced by a command or returned by the editing frame is held to the strict
+     * rule, whatever the document kind keeps from an import.
+     */
+    assertWritable(nodes: readonly DocumentNode[]): void;
+    document(input: unknown): EditorDocument;
+    export(document: EditorDocumentData | EditorDocument): SourceInput;
+    /**
+     * Source and notices of a document about to become the current one, validated once here
+     * (the codec asserts the policy again and verifies its output by reparse).
+     */
+    render(document: EditorDocument): {
+        readonly source: SourceInput;
+        readonly diagnostics: readonly Diagnostic[];
+    };
+}

package/dist/application/document-commands.d.ts

@@ -0,0 +1,51 @@
+import type { EditorDocumentData, SourceInput } from '../core/document';
+import { EditorDocument } from '../core/document';
+import { BlockCatalog } from '../core/catalog';
+import type { BlockType } from '../core/catalog';
+import { ContentService } from './content-service';
+import type { EmailInsertionUnit } from './email-insertion';
+import type { AssetReference } from './host';
+/** Source of a block to insert. Generated e-mail blocks may state the unit they stand for. */
+export interface InsertionSource extends SourceInput {
+    readonly insertion?: EmailInsertionUnit;
+}
+export declare class DocumentMutationService {
+    private readonly content;
+    private readonly catalog;
+    private sequence;
+    private readonly formats;
+    private readonly markup;
+    private readonly emails;
+    constructor(content: ContentService, catalog: BlockCatalog);
+    text(document: EditorDocumentData, id: string, value: string): EditorDocument;
+    canEditRichText(document: EditorDocumentData, id: string): boolean;
+    validateRichTextProjection(document: EditorDocumentData, id: string, html: string): void;
+    richText(document: EditorDocumentData, id: string, html: string): EditorDocument;
+    attribute(document: EditorDocumentData, id: string, name: string, value: string): EditorDocument;
+    style(document: EditorDocumentData, id: string, property: string, value: string): EditorDocument;
+    connectFormReference(document: EditorDocumentData, reference: string, id?: string, parentId?: string, index?: number): EditorDocument;
+    attachAsset(document: EditorDocumentData, asset: AssetReference, id?: string, parentId?: string, index?: number): EditorDocument;
+    insert(document: EditorDocumentData, source: InsertionSource, parentId?: string, index?: number): EditorDocument;
+    add(document: EditorDocumentData, type: BlockType, parentId?: string, index?: number): EditorDocument;
+    remove(document: EditorDocumentData, id: string): EditorDocument;
+    duplicate(document: EditorDocumentData, id: string): EditorDocument;
+    move(document: EditorDocumentData, id: string, parentId: string | undefined, index: number): EditorDocument;
+    private richTextChildren;
+    private insertionNodes;
+    private restoreRichAttributes;
+    private mutate;
+    private next;
+    private id;
+    private hidden;
+    private position;
+    private find;
+    private findTag;
+    private parent;
+    private body;
+    private assertText;
+    private assertStructuralEdit;
+    private assertParent;
+    private unique;
+    private mutable;
+    private copyNode;
+}

package/dist/application/document-metadata.d.ts

@@ -0,0 +1,30 @@
+import type { EditorDocumentData } from '../core/document';
+import { EditorDocument } from '../core/document';
+import { ContentService } from './content-service';
+export interface DocumentMetadata {
+    readonly title: string;
+    /** Hidden preview text of an e-mail; undefined for a page, empty when there is none. */
+    readonly preheader: string | undefined;
+}
+export interface MetadataIdentityPort {
+    next(): string;
+}
+/**
+ * Title and preheader are part of what a recipient receives, so they are document content
+ * edited by commands like any other, never sample text left behind by a template.
+ */
+export declare class DocumentMetadataService {
+    private readonly content;
+    private readonly identifiers;
+    constructor(content: ContentService, identifiers: MetadataIdentityPort);
+    read(document: EditorDocumentData): DocumentMetadata;
+    title(document: EditorDocumentData, value: string): EditorDocument;
+    preheader(document: EditorDocumentData, value: string): EditorDocument;
+    /** The first content of the body when it is a hidden block which only holds text. */
+    private preheaderNode;
+    private next;
+    private text;
+    private control;
+    private findTag;
+    private copy;
+}

package/dist/application/document-presentation.d.ts

@@ -0,0 +1,35 @@
+import { DOCUMENT_STYLE_PROPERTIES } from '../core/document-presentation';
+import type { DocumentStyleProperty, ImageSizeSettings } from '../core/document-presentation';
+import { EditorDocument } from '../core/document';
+import type { EditorDocumentData } from '../core/document';
+import { ContentService } from './content-service';
+export { IMAGE_SIZE_LIMITS, DOCUMENT_STYLE_PROPERTIES } from '../core/document-presentation';
+export type { DocumentStyleProperty, ImageSizeSettings } from '../core/document-presentation';
+export interface ImageSizeContext {
+    readonly id: string;
+    readonly width?: number;
+    readonly height?: number;
+    readonly ratio?: number;
+}
+export interface DocumentStyleContext {
+    readonly id: string;
+    readonly properties: typeof DOCUMENT_STYLE_PROPERTIES;
+    readonly originalProperties: readonly DocumentStyleProperty[];
+    readonly values: Readonly<Partial<Record<DocumentStyleProperty, string>>>;
+}
+/** Presentation changes are one validated document transaction, never DOM mutations. */
+export declare class DocumentPresentationService {
+    private readonly content;
+    private readonly settings;
+    constructor(content: ContentService);
+    image(document: EditorDocumentData, id: string): ImageSizeContext | undefined;
+    resize(document: EditorDocumentData, id: string, input: ImageSizeSettings): EditorDocument;
+    styles(document: EditorDocumentData): DocumentStyleContext | undefined;
+    style(document: EditorDocumentData, property: DocumentStyleProperty, value: string): EditorDocument;
+    private ratio;
+    private pixels;
+    private number;
+    private find;
+    private all;
+    private change;
+}

package/dist/application/email-insertion.d.ts

@@ -0,0 +1,76 @@
+import type { DocumentNode } from '../core/document';
+export interface MutableNode {
+    id: string;
+    type: DocumentNode['type'];
+    tag?: string;
+    value?: string;
+    attrs?: Record<string, string>;
+    children?: MutableNode[];
+    metadata?: NonNullable<DocumentNode['metadata']>;
+}
+/** The unit a generated e-mail block is meant to be inserted as. */
+export type EmailInsertionUnit = 'content' | 'section';
+interface EmailColumn<T> {
+    /** Presentation table owned by the column; its body holds one row per content element. */
+    readonly table: T;
+    readonly body: T;
+    readonly rows: readonly T[];
+}
+export interface CompiledEmailBlock {
+    /** False for plain snippets, which keep the generic insertion rules. */
+    readonly compiled: boolean;
+    /** Section-level sequence: sections and their Outlook conditional comments. */
+    readonly units: readonly DocumentNode[];
+    /** Undefined when a compiled section has a shape this planner does not know. */
+    readonly columns: readonly EmailColumn<DocumentNode>[] | undefined;
+}
+export interface EmailInsertionPlan {
+    readonly parent: MutableNode | undefined;
+    readonly target: MutableNode[];
+    readonly index: number;
+    readonly nodes: readonly DocumentNode[];
+}
+/**
+ * Chooses what a generated e-mail block contributes to a destination. Inside a column or
+ * cell only content rows travel; at section level the section goes with its balanced pair of
+ * Outlook comments. The preheader, the title and the article wrapper of the compiled block
+ * never enter the document. Anything that cannot be placed safely is refused.
+ */
+export declare class EmailInsertionPlanner {
+    private readonly id;
+    private readonly hidden;
+    constructor(id: () => string, hidden: (style: string) => boolean);
+    block(body: readonly DocumentNode[]): CompiledEmailBlock;
+    place(roots: MutableNode[], parent: MutableNode | undefined, index: number | undefined, block: CompiledEmailBlock, requested?: EmailInsertionUnit): EmailInsertionPlan;
+    /** A new image is born inside the content unit generated image blocks use. */
+    placeImage(roots: MutableNode[], parent: MutableNode | undefined, index: number | undefined, image: MutableNode): EmailInsertionPlan;
+    /**
+     * Where content rows go when the destination is part of a recognized section: after the
+     * selected row of a column, or at the end of the last column when the section shell (its
+     * row or the cell which holds the columns) was selected. A cell beside the selected row,
+     * or flow content between the Outlook ghost cells, would break the column layout.
+     */
+    private rowHost;
+    private sectionLevel;
+    /**
+     * Between two sections one comment closes a ghost table and opens the next. It becomes
+     * its two halves, so a new section fits between them with a pair of its own.
+     */
+    private splitBridge;
+    private assertBalanced;
+    /** Flow content next to Outlook ghost cells would land in the wrong table for one client. */
+    private assertFlowDestination;
+    private columns;
+    private descend;
+    private conditional;
+    private layoutUnit;
+    private wrapper;
+    private preheader;
+    private blank;
+    private trim;
+    private position;
+    private find;
+    /** Ancestors of the node, outermost first and ending with the node itself. */
+    private chain;
+}
+export {};

package/dist/application/host.d.ts

@@ -0,0 +1,36 @@
+import type { EditorDocumentData, SourceInput } from '../core/document';
+export interface AssetReference {
+    readonly id: string;
+    readonly url: string;
+    readonly alt: string;
+}
+export interface AssetPort {
+    upload(file: File, signal?: AbortSignal): Promise<AssetReference>;
+    resolve(id: string, signal?: AbortSignal): Promise<{
+        url: string;
+        alt: string;
+    }>;
+}
+export interface StorePort {
+    save(document: EditorDocumentData, source: SourceInput, expectedRevision: number, signal?: AbortSignal): Promise<{
+        revision: number;
+    }>;
+}
+export interface SlotsPort {
+    resolve(kind: 'form' | 'footer', id: string, signal?: AbortSignal): Promise<string>;
+}
+export interface HostAdapters {
+    assets?: AssetPort;
+    store?: StorePort;
+    slots?: SlotsPort;
+}
+export declare class HostIntegration {
+    private readonly adapters;
+    private saveSequence;
+    private active;
+    constructor(adapters?: HostAdapters);
+    save(document: EditorDocumentData, source: SourceInput, expectedRevision: number): Promise<number | undefined>;
+    get assets(): AssetPort | undefined;
+    get slots(): SlotsPort | undefined;
+    dispose(): void;
+}

package/dist/application/image-link.d.ts

@@ -0,0 +1,36 @@
+import type { EditorDocumentData } from '../core/document';
+import { EditorDocument } from '../core/document';
+import { ContentService } from './content-service';
+export interface ImageLinkOptions {
+    readonly target?: '_blank' | '_self';
+}
+export interface ImageLinkContext {
+    readonly imageId: string;
+    readonly anchorId?: string;
+    readonly href: string;
+    readonly target: string;
+    readonly rel: string;
+    readonly shared: boolean;
+    readonly editable: boolean;
+    readonly reason?: 'shared-structure' | 'shared-identity' | 'nested-link';
+}
+export interface ImageLinkUrlPort {
+    isSafe(value: string, purpose: 'link'): boolean;
+}
+export interface ImageLinkIdentityPort {
+    next(): string;
+}
+/** Changes the link of one image while retaining unrelated content and link destinations. */
+export declare class ImageLinkService {
+    private readonly content;
+    private readonly urls;
+    private readonly identifiers;
+    constructor(content: ContentService, urls: ImageLinkUrlPort, identifiers: ImageLinkIdentityPort);
+    context(document: EditorDocumentData, imageId: string): ImageLinkContext | undefined;
+    update(document: EditorDocumentData, imageId: string, href: string, options?: ImageLinkOptions): EditorDocument;
+    private attributes;
+    private locate;
+    private substantive;
+    private path;
+    private replace;
+}

package/dist/application/section-layout.d.ts

@@ -0,0 +1,25 @@
+import { EditorDocument } from '../core/document';
+import type { EditorDocumentData, SourceInput } from '../core/document';
+import type { SectionLayoutContext, SectionLayoutPatch, SectionLayoutProjection, SectionLayoutSettings } from '../core/section-layout';
+import { ContentService } from './content-service';
+export interface SectionScaffoldPort {
+    create(settings: SectionLayoutSettings, original: SectionLayoutProjection): Promise<SourceInput>;
+    supports(projection: SectionLayoutProjection): boolean;
+}
+export interface SectionIdentityPort {
+    next(): string;
+}
+/** Changes a supported section, retaining content identities and untouched document regions. */
+export declare class SectionLayoutService {
+    private readonly content;
+    private readonly identities;
+    private readonly scaffold?;
+    private readonly policy;
+    constructor(content: ContentService, identities: SectionIdentityPort, scaffold?: SectionScaffoldPort | undefined);
+    context(document: EditorDocumentData, id: string): SectionLayoutContext | undefined;
+    update(document: EditorDocumentData, id: string, patch: SectionLayoutPatch): Promise<EditorDocument>;
+    private styles;
+    private fresh;
+    private all;
+    private replace;
+}

package/dist/application/session.d.ts

@@ -0,0 +1,128 @@
+import { DocumentPresentationService } from './document-presentation';
+import { DocumentMetadataService } from './document-metadata';
+import type { DocumentMetadata } from './document-metadata';
+import type { DocumentStyleProperty, ImageSizeSettings } from './document-presentation';
+import type { Diagnostic, EditorDocumentData, EditorMode, SourceInput } from '../core/document';
+import { DocumentHistory } from '../core/history';
+import type { BlockType } from '../core/catalog';
+import { ContentService } from './content-service';
+import { DocumentMutationService } from './document-commands';
+import type { InsertionSource } from './document-commands';
+import { SectionLayoutService } from './section-layout';
+import type { SectionLayoutContext, SectionLayoutPatch } from '../core/section-layout';
+import { ImageLinkService } from './image-link';
+import type { ImageLinkContext, ImageLinkOptions } from './image-link';
+import { HostIntegration } from './host';
+import type { AssetReference } from './host';
+export interface PendingRichTextDraft {
+    readonly id: string;
+    readonly html: string;
+    readonly originalHtml: string;
+    readonly changed: boolean;
+    readonly valid: boolean;
+    readonly blocked?: 'oversized';
+    readonly documentId: string;
+    readonly baseRevision: number;
+    readonly editGeneration: number;
+}
+export interface EditorState {
+    readonly document: EditorDocumentData;
+    readonly mode: EditorMode;
+    readonly source: SourceInput;
+    readonly draftSource: SourceInput;
+    readonly diagnostics: readonly Diagnostic[];
+    readonly selectedNodeId: string | undefined;
+    readonly pendingRichText?: PendingRichTextDraft;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly readOnly: boolean;
+    readonly readonly: boolean;
+    readonly dirty: boolean;
+    readonly editGeneration: number;
+}
+export interface SessionOptions {
+    readonly document: EditorDocumentData;
+    /** Notices of the import which produced the initial document, e.g. what was removed. */
+    readonly diagnostics?: readonly Diagnostic[];
+    readonly readOnly?: boolean;
+    readonly persistedRevision?: number;
+    readonly onObserverError?: (error: unknown) => void;
+}
+export interface SessionServices {
+    readonly content: ContentService;
+    readonly mutations: DocumentMutationService;
+    readonly imageLinks: ImageLinkService;
+    readonly presentation?: DocumentPresentationService;
+    readonly metadata?: DocumentMetadataService;
+    readonly sectionLayouts?: SectionLayoutService;
+    readonly history: DocumentHistory;
+    readonly host: HostIntegration;
+}
+export declare class EditorSession {
+    #private;
+    private readonly services;
+    private readonly options;
+    constructor(services: SessionServices, options: SessionOptions);
+    getState(): EditorState;
+    snapshot(): EditorDocumentData;
+    exportSource(): SourceInput;
+    setReadOnly(value: boolean): void;
+    subscribe(listener: (state: EditorState) => void): () => void;
+    select(id: string | undefined): boolean;
+    setDraftSource(source: SourceInput): void;
+    commitDraft(): boolean;
+    importSource(source: SourceInput): boolean;
+    importJson(input: unknown): boolean;
+    setMode(mode: EditorMode): boolean;
+    beginRichText(id: string, initialHtml: string): boolean;
+    updateRichTextDraft(html: string): boolean;
+    restoreRichTextDraft(draft: Pick<PendingRichTextDraft, 'id' | 'html' | 'blocked'>, initialHtml: string): boolean;
+    commitRichText(): boolean;
+    cancelRichText(): void;
+    inlineStyles(id: string): Readonly<Record<string, string>>;
+    /** Title and, in an e-mail, preheader of the document. */
+    documentMetadata(): DocumentMetadata | undefined;
+    updateTitle(value: string): boolean;
+    updatePreheader(value: string): boolean;
+    imageSize(id: string): import("./document-presentation").ImageSizeContext | undefined;
+    updateImageSize(id: string, settings: ImageSizeSettings): boolean;
+    documentStyles(): import("./document-presentation").DocumentStyleContext | undefined;
+    updateDocumentStyle(property: DocumentStyleProperty, value: string): boolean;
+    updateText(id: string, value: string): boolean;
+    updateRichText(id: string, html: string): boolean;
+    updateAttribute(id: string, name: string, value: string): boolean;
+    updateStyle(id: string, property: string, value: string): boolean;
+    connectFormReference(reference: string, id?: string, parentId?: string, index?: number): boolean;
+    attachAsset(asset: AssetReference, id?: string, parentId?: string, index?: number): boolean;
+    imageLink(imageId: string): ImageLinkContext | undefined;
+    updateImageLink(imageId: string, href: string, options?: ImageLinkOptions): boolean;
+    layoutSettings(id: string): SectionLayoutContext | undefined;
+    updateLayout(id: string, patch: SectionLayoutPatch): Promise<boolean>;
+    addBlock(type: BlockType, parentId?: string, index?: number): boolean;
+    insertSource(source: InsertionSource, parentId?: string, index?: number): boolean;
+    removeBlock(id: string): boolean;
+    duplicateBlock(id: string): boolean;
+    moveBlock(id: string, parentId: string | undefined, index: number): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    save(): Promise<boolean>;
+    dispose(): void;
+    private metadata;
+    /** What an import removed stays visible next to what the committed document holds. */
+    private notices;
+    private presentation;
+    private change;
+    private restore;
+    private commit;
+    private fail;
+    private rejectRichTextSize;
+    private boundedRichText;
+    private canWrite;
+    private assertActive;
+    private hasPendingDraft;
+    private emit;
+    private freezeBroadcast;
+    /** False when the listener threw; the failure was already reported. */
+    private notify;
+    private find;
+}