oasis-editor 0.0.137 → 0.0.139

package/dist/adapters/mountController.d.ts

@@ -6,7 +6,18 @@ import { OasisEditorAppProps, OasisEditorClient } from '../index.ts';
  * around their own reactivity hooks.
  */
 export interface OasisMountController {
+    /**
+     * Mounts the editor into the given container.
+     * @param container - The DOM element to mount into.
+     * @param props - Editor configuration props.
+     * @param onClient - Optional callback receiving the mounted client.
+     */
     mount(container: HTMLElement, props: OasisEditorAppProps, onClient?: (client: OasisEditorClient) => void): void;
+    /** Unmounts the editor and releases resources. */
     unmount(): void;
 }
+/**
+ * Creates a framework-agnostic mount controller.
+ * @returns A new OasisMountController.
+ */
 export declare function createOasisMountController(): OasisMountController;

package/dist/adapters/react.d.ts

@@ -1,6 +1,7 @@
 import { default as React } from 'react';
 import { OasisEditorAppProps, OasisEditorClient } from '../index.ts';
 
+/** Props for the React adapter component, extending the standard editor app props. */
 export type ReactOasisEditorProps = OasisEditorAppProps & {
     /**
      * Receives the mounted Oasis client. Props are mount-only for this adapter;
@@ -8,4 +9,11 @@ export type ReactOasisEditorProps = OasisEditorAppProps & {
      */
     onClient?: (client: OasisEditorClient) => void;
 };
+/**
+ * React component that mounts the Oasis editor. Mount-only — remount to
+ * apply a new configuration.
+ *
+ * @param props - The editor configuration props.
+ * @returns A React element wrapping the editor.
+ */
 export declare const OasisEditor: React.FC<ReactOasisEditorProps>;

package/dist/adapters/ui.d.ts

@@ -1,2 +1,2 @@
-export { ActionRow, Button, Checkbox, ColorField, ColorPicker, ColorPicker as ToolbarColorPicker, Dialog, DialogFooter, FieldGroup, FieldRow, FloatingActionButton, FormField, Grid, GridPicker, Heading, IconButton, Menu, NumberField, Popover, Radio, RadioGroup, Select, SelectField, Separator, SidePanel, SidePanelBody, SidePanelFooter, SidePanelHeader, SplitButton, Stack, StatusText, SurfaceButton, Tabs, Text, TextAreaField, TextField, ToolbarButton, ToggleChip, } from '../index.ts';
+export { Button, Checkbox, ColorField, ColorPicker, ColorPicker as ToolbarColorPicker, Dialog, DialogFooter, FieldGroup, FieldRow, FloatingActionButton, FormField, Grid, GridPicker, Heading, IconButton, Menu, NumberField, Popover, Radio, RadioGroup, Select, SelectField, Separator, SidePanel, SidePanelBody, SidePanelFooter, SidePanelHeader, SplitButton, Stack, StatusText, SurfaceButton, Tabs, Text, TextAreaField, TextField, ToolbarButton, ToggleChip, } from '../index.ts';
 export type { ActionRowProps, ButtonProps, CheckboxProps, ColorFieldProps, ColorPickerKind, ColorPickerProps, DialogFooterProps, DialogProps, FieldGroupProps, FieldRowProps, FloatingActionButtonProps, FormFieldProps, GridOffset, GridPickerProps, GridProps, GridSize, HeadingProps, IconButtonProps, MenuProps, NumberFieldProps, PopoverProps, PopoverTriggerApi, RadioGroupOption, RadioGroupProps, RadioProps, ResponsiveValue, SelectFieldOption, SelectFieldProps, SeparatorProps, SidePanelProps, SidePanelSectionProps, SplitButtonProps, StackProps, StatusTextProps, SurfaceButtonProps, TabsItem, TabsProps, TextAreaFieldProps, TextProps, TextFieldProps, ToolbarButtonProps, ToolbarSelectProps, ToggleChipProps, } from '../index.ts';

package/dist/adapters/vue.d.ts

@@ -1,6 +1,16 @@
 import { VNode, RendererNode, RendererElement, PropType } from 'vue';
 import { OasisEditorAppProps, OasisEditorClient } from '../index.ts';
 
+/**
+ * Vue 3 component that mounts the Oasis editor. Mount-only — remount to
+ * apply a new configuration.
+ *
+ * @component
+ * @param props.config - Editor configuration props.
+ * @param props.class - CSS class for the container.
+ * @param props.style - CSS style for the container.
+ * @param props.onClient - Callback receiving the mounted client.
+ */
 export declare const OasisEditor: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     config: {
         type: () => OasisEditorAppProps;

package/dist/app/bootstrap/createOasisEditorApp.d.ts

@@ -1,5 +1,14 @@
 import { OasisEditorAppProps } from '../../ui/OasisEditorApp.js';
 import { OasisEditorClient } from '../client/OasisEditorClient.js';
 
+/** An Oasis editor instance created via {@link createOasisEditor}. */
 export type OasisEditorInstance = OasisEditorClient;
+/**
+ * Mounts the full Oasis editor application (document shell) into a container
+ * element and returns the public editor client API.
+ *
+ * @param container - The DOM element to mount the editor into.
+ * @param props - Optional editor configuration props.
+ * @returns The editor client API.
+ */
 export declare function createOasisEditor(container: HTMLElement, props?: OasisEditorAppProps): OasisEditorInstance;

package/dist/app/bootstrap/createOasisEditorContainer.d.ts

@@ -1,5 +1,14 @@
 import { OasisEditorContainerProps } from '../../ui/OasisEditorContainer.js';
 import { OasisEditorClient } from '../client/OasisEditorClient.js';
 
+/** An Oasis editor container instance created via {@link createOasisEditorContainer}. */
 export type OasisEditorContainerInstance = OasisEditorClient;
+/**
+ * Mounts the Oasis editor container component into a container element and
+ * returns the public editor client API.
+ *
+ * @param container - The DOM element to mount into.
+ * @param props - Optional container props.
+ * @returns The editor client API.
+ */
 export declare function createOasisEditorContainer(container: HTMLElement, props?: OasisEditorContainerProps): OasisEditorContainerInstance;

package/dist/app/client/OasisEditorClient.d.ts

@@ -2,80 +2,305 @@ import { EditorDocument, EditorSelection, EditorState } from '../../core/model.j
 import { Editor } from '../../core/Editor.js';
 import { ToolbarCommandState } from '../../ui/components/Toolbar/schema/items.js';
 import { TypedCommandBus } from '../../core/commands/publicCommandTypes.js';
+import { queryDocument, ApplyEditRequest, ApplyEditValue, DocumentRange, DocumentSelector, OasisResult, SemanticDocumentSnapshot } from './publicDocumentApi.js';
+import { ToolbarRegistry } from '../../ui/components/Toolbar/registry/ToolbarRegistry.js';
+import { MenuRegistry } from '../../ui/components/Menubar/menuRegistry.js';
 
-export type OasisEditorClientEvent = "ready" | "change" | "documentChange" | "selectionChange" | "error";
+/** UI-related editor state that can be toggled or configured at runtime. */
+export interface OasisEditorUiState {
+    showChrome?: boolean;
+    showTitleBar?: boolean;
+    showMenubar?: boolean;
+    showToolbar?: boolean;
+    showOutline?: boolean;
+    shell?: "document" | "inline" | "balloon";
+    locale?: "pt-BR" | "en";
+    toolbar?: {
+        view?: "ribbon" | "compact";
+        layout?: "overflow" | "wrap";
+    };
+    viewportHeight?: number | string;
+    readOnly?: boolean;
+}
+/** Events emitted by the editor client lifecycle. */
+export type OasisEditorClientEvent = "ready" | "change" | "documentChange" | "selectionChange" | "uiChange" | "error";
+/** Payload types associated with each client event. */
 export interface OasisEditorClientEvents {
     ready: Editor;
     change: EditorState;
     documentChange: EditorDocument;
     selectionChange: EditorSelection;
+    uiChange: OasisEditorUiState;
     error: unknown;
 }
+/**
+ * Handler signature for subscribing to client events.
+ * @typeParam TEvent - The specific event type being handled.
+ */
 export type OasisEditorClientEventHandler<TEvent extends OasisEditorClientEvent = OasisEditorClientEvent> = (payload: OasisEditorClientEvents[TEvent]) => void;
+/** Low-level document CRUD API exposed through the editor client. */
 export interface OasisEditorDocumentApi {
+    /** Returns the current document. */
     get(): EditorDocument;
+    /** @param document - The new document to set. Marks the editor dirty. */
     set(document: EditorDocument): void;
+    /** @param document - The document to load. Does NOT mark the editor dirty. */
     load(document: EditorDocument): void;
+    /** @param updater - Function that receives the current document and returns the new one. */
     update(updater: (document: EditorDocument) => EditorDocument): void;
+    /** Resets the document to its initial empty state. */
     reset(): void;
+    /** @returns A promise that resolves once the document is persisted. */
     save(): Promise<void>;
+    /** @returns `true` if the document has unsaved changes. */
     isDirty(): boolean;
+    /** Marks the document as clean (no unsaved changes). */
     markClean(): void;
+    /** @returns A monotonically increasing version counter, incremented on every mutation. */
+    version(): number;
+}
+/** Query API for reading the document without mutation. */
+export interface OasisEditorQueryApi {
+    /** @returns A snapshot of the entire document (text, outline, nodes). */
+    snapshot(): SemanticDocumentSnapshot;
+    /**
+     * @param target - Optional selector or range to scope the text to.
+     * @returns Plain text for the whole document or a specific target/range.
+     */
+    getText(target?: DocumentSelector | DocumentRange): string;
+    /**
+     * @param selector - The selector identifying the node.
+     * @returns A semantic node descriptor, or `null` if not found.
+     */
+    getNode(selector: DocumentSelector): ReturnType<ReturnType<typeof queryDocument>["getNode"]>;
+    /**
+     * @param text - The text to search for.
+     * @returns An array of match descriptors.
+     */
+    find(text: string): ReturnType<ReturnType<typeof queryDocument>["find"]>;
+    /** @returns The document outline (heading-based hierarchy). */
+    outline(): ReturnType<ReturnType<typeof queryDocument>["outline"]>;
+}
+/** Edit API for applying structured operations to the document. */
+export interface OasisEditorEditApi {
+    /**
+     * Applies one or more edit operations.
+     * @param request - The edit request containing operations and optional version checks.
+     * @returns A result indicating success or failure with error details.
+     */
+    apply(request: ApplyEditRequest): Promise<OasisResult<ApplyEditValue>>;
 }
+/** Selection read/write API. */
 export interface OasisEditorSelectionApi {
+    /** @returns The current selection. */
     get(): EditorSelection;
+    /** @param selection - The new selection to set. */
     set(selection: EditorSelection): void;
 }
+/** Focus management API. */
 export interface OasisEditorFocusApi {
+    /** Focuses the editor input area. */
     focus(): void;
+    /** Blurs the editor input area. */
     blur(): void;
 }
+/** History (undo/redo) API. */
 export interface OasisEditorHistoryApi {
+    /** @returns The result of undoing the last operation. */
     undo(): unknown;
+    /** @returns The result of reapplying the last undone operation. */
     redo(): unknown;
+    /** @returns `true` if undo is available. */
     canUndo(): boolean;
+    /** @returns `true` if redo is available. */
     canRedo(): boolean;
+    /** Clears the entire undo/redo history. */
     clear(): void;
 }
+/** File import API. */
 export interface OasisEditorImportApi {
+    /**
+     * Imports a .docx file from a browser File object.
+     * @param file - The .docx file to import.
+     */
     docx(file: File): Promise<void>;
 }
+/** File export API. */
 export interface OasisEditorExportApi {
+    /** @returns A promise resolving to the exported .docx data. */
     docx(): Promise<unknown>;
+    /** @returns A promise resolving to the exported .pdf data. */
     pdf(): Promise<unknown>;
 }
+/** Data input/output API with progress reporting and result wrapping. */
+export interface OasisEditorDataIoApi {
+    /**
+     * Imports a document from raw data.
+     * @param request - Import configuration including format, data, and optional progress callback.
+     * @returns A wrapped result indicating success or failure.
+     */
+    import(request: {
+        format: "docx";
+        data: Blob | ArrayBuffer | Uint8Array;
+        filename?: string;
+        signal?: AbortSignal;
+        onProgress?: (progress: unknown) => void;
+    }): Promise<OasisResult<{
+        format: "docx";
+    }>>;
+    /**
+     * Exports the document as a Blob in the requested format.
+     * @param request - Export configuration including format and optional filename.
+     * @returns A wrapped result containing the blob.
+     */
+    export(request: {
+        format: "docx" | "pdf";
+        filename?: string;
+    }): Promise<OasisResult<{
+        format: "docx" | "pdf";
+        blob: Blob;
+        arrayBuffer: () => Promise<ArrayBuffer>;
+    }>>;
+}
+/** UI configuration and chrome API. */
+export interface OasisEditorUiApi {
+    /** @returns The current UI state. */
+    state(): OasisEditorUiState;
+    /**
+     * Applies a partial UI state patch.
+     * @param patch - The partial state to apply.
+     * @returns The new UI state after applying the patch.
+     */
+    update(patch: OasisEditorUiState): OasisEditorUiState;
+    /** @param value - Whether the editor should be read-only. */
+    setReadOnly(value: boolean): void;
+    /** Zoom controls. */
+    zoom: {
+        get(): number;
+        set(value: number): void;
+        adjust(delta: number): void;
+    };
+    /** Chrome visibility controls. */
+    chrome: {
+        setVisible(value: boolean): void;
+    };
+    /** Title bar visibility control. */
+    titleBar: {
+        setVisible(value: boolean): void;
+    };
+    /** Menubar visibility and item registry. */
+    menubar: {
+        setVisible(value: boolean): void;
+        items: MenuRegistry;
+    };
+    /** Toolbar visibility and item registry. */
+    toolbar: {
+        setVisible(value: boolean): void;
+        items: ToolbarRegistry;
+    };
+    /** Outline panel visibility control. */
+    outline: {
+        setVisible(value: boolean): void;
+    };
+    /** @param value - The shell mode to set. */
+    shell: {
+        set(value: "document" | "inline" | "balloon"): void;
+    };
+    /** @param value - The locale to set. */
+    locale: {
+        set(value: "pt-BR" | "en"): void;
+    };
+}
+/**
+ * The main public API surface of an Oasis Editor instance. Returned by
+ * {@link createOasisEditor} and {@link createOasisEditorContainer}.
+ */
 export interface OasisEditorClient {
+    /** Resolves once the editor runtime is fully initialized. */
     readonly ready: Promise<Editor>;
+    /** Typed command bus for dispatching editor commands. */
     readonly commands: TypedCommandBus<ToolbarCommandState>;
+    /** Document CRUD API. */
     readonly document: OasisEditorDocumentApi;
+    /** Selection API. */
     readonly selection: OasisEditorSelectionApi;
+    /** Focus API. */
     readonly focus: OasisEditorFocusApi;
+    /** History (undo/redo) API. */
     readonly history: OasisEditorHistoryApi;
+    /** File import API. */
     readonly import: OasisEditorImportApi;
+    /** File export API. */
     readonly export: OasisEditorExportApi;
+    /** Document query API. */
+    readonly query: OasisEditorQueryApi;
+    /** Document edit API. */
+    readonly edit: OasisEditorEditApi;
+    /** Data import/export API with result wrapping. */
+    readonly io: OasisEditorDataIoApi;
+    /** UI configuration API. */
+    readonly ui: OasisEditorUiApi;
+    /** Disposes the editor, releasing resources. */
     dispose(): void | Promise<void>;
+    /** @returns The current editor state. */
     getState(): EditorState;
+    /** @returns The current document. */
     getDocument(): EditorDocument;
+    /** @param document - The new document to set. Marks the editor dirty. */
     setDocument(document: EditorDocument): void;
+    /** @param document - The document to load. Does NOT mark the editor dirty. */
     loadDocument(document: EditorDocument): void;
+    /**
+     * @param updater - Function that receives the current document and returns the new one.
+     */
     updateDocument(updater: (document: EditorDocument) => EditorDocument): void;
+    /** Resets the document to its initial state. */
     resetDocument(): void;
+    /** @returns A promise that resolves once the document is persisted. */
     save(): Promise<void>;
+    /** @returns `true` if the document has unsaved changes. */
     isDirty(): boolean;
+    /** Marks the document as clean. */
     markClean(): void;
+    /** @returns The current selection. */
     getSelection(): EditorSelection;
+    /** @param selection - The new selection to set. */
     setSelection(selection: EditorSelection): void;
+    /** Focuses the editor. */
     focusEditor(): void;
+    /** Blurs the editor. */
     blurEditor(): void;
+    /**
+     * Subscribes to a client event.
+     * @param event - The event name.
+     * @param callback - The handler to invoke when the event fires.
+     * @returns An unsubscribe function.
+     */
     on<TEvent extends OasisEditorClientEvent>(event: TEvent, callback: OasisEditorClientEventHandler<TEvent>): () => void;
+    /**
+     * Subscribes to a single emission of a client event.
+     * @param event - The event name.
+     * @param callback - The handler to invoke once.
+     * @returns An unsubscribe function.
+     */
     once<TEvent extends OasisEditorClientEvent>(event: TEvent, callback: OasisEditorClientEventHandler<TEvent>): () => void;
+    /**
+     * Removes a previously subscribed event handler.
+     * @param event - The event name.
+     * @param callback - The handler to remove.
+     */
     off<TEvent extends OasisEditorClientEvent>(event: TEvent, callback: OasisEditorClientEventHandler<TEvent>): void;
 }
+/**
+ * Internal contract used by the host (editor UI shell) to drive the client.
+ * Extends the public {@link OasisEditorClient} with connection lifecycle methods.
+ */
 export interface OasisEditorClientHost {
     getRuntimeEditor(): Editor | null;
     getState(): EditorState;
     getDocument(): EditorDocument;
     setDocument(document: EditorDocument): void;
+    applyTransactionalState?(producer: (state: EditorState) => EditorState): void;
     resetDocument(): void;
     saveDocument(): Promise<void>;
     getSelection(): EditorSelection;
@@ -86,12 +311,40 @@ export interface OasisEditorClientHost {
     importDocx(file: File): Promise<void>;
     exportDocx(): Promise<unknown>;
     exportPdf(): Promise<unknown>;
+    exportDocxBlob(): Promise<Blob>;
+    exportPdfBlob(): Promise<Blob>;
+    getUiState?(): OasisEditorUiState;
+    updateUiState?(patch: OasisEditorUiState): OasisEditorUiState;
+    getZoom?(): number;
+    setZoom?(value: number): void;
+    adjustZoom?(delta: number): void;
+    toolbarRegistry?: ToolbarRegistry;
+    menuRegistry?: MenuRegistry;
 }
+/**
+ * Combined interface for the internal client-controller, extending the public
+ * API with host connection, disposal, ready resolution, and event emission.
+ */
 export interface OasisEditorClientController extends OasisEditorClient {
+    /** @param host - The host to connect. */
     connectHost(host: OasisEditorClientHost): void;
+    /** @param dispose - The dispose function to call on cleanup. */
     setDispose(dispose: () => void | Promise<void>): void;
+    /** @param editor - The editor instance that is now ready. */
     resolveReady(editor: Editor): void;
+    /** @param error - The error that prevented initialization. */
     rejectReady(error: unknown): void;
+    /**
+     * Emits a client event.
+     * @param event - The event name.
+     * @param payload - The event payload.
+     */
     emit<TEvent extends OasisEditorClientEvent>(event: TEvent, payload: OasisEditorClientEvents[TEvent]): void;
 }
+/**
+ * Creates a new editor client controller. The client is a lightweight broker
+ * that connects the public API surface to the host runtime once mounted.
+ *
+ * @returns A new {@link OasisEditorClientController} instance.
+ */
 export declare function createOasisEditorClient(): OasisEditorClientController;

package/dist/app/client/publicDocumentApi.d.ts

@@ -0,0 +1,223 @@
+import { EditorBlockNode, EditorDocument, EditorParagraphNode, EditorPosition, EditorTextStyle } from '../../core/model.js';
+import { createEditorParagraph, createEditorTable } from '../../core/editorState.js';
+
+/** Current version of the editor document schema. */
+export declare const EDITOR_SCHEMA_VERSION = 1;
+/**
+ * Selects a specific node in the document tree. Used as a targeting mechanism
+ * for edit operations and queries.
+ */
+export type DocumentSelector = {
+    nodeId: string;
+} | {
+    text: string;
+    occurrence?: number;
+} | {
+    headingPath: string[];
+} | {
+    tableId: string;
+    row: number;
+    column: number;
+} | {
+    bookmark: string;
+} | {
+    contentControlTag: string;
+};
+/** A range between two positions in the document. */
+export interface DocumentRange {
+    start: EditorPosition;
+    end: EditorPosition;
+}
+/** Descriptor for a node in a semantic document snapshot. */
+export interface SemanticNode {
+    id: string;
+    type: string;
+    text?: string;
+    node: unknown;
+}
+/** Descriptor for a text match found by the find API. */
+export interface DocumentMatch {
+    selector: {
+        nodeId: string;
+    };
+    paragraphId: string;
+    text: string;
+    start: number;
+    end: number;
+}
+/** An item in the document outline (heading hierarchy). */
+export interface DocumentOutlineItem {
+    id: string;
+    level: number;
+    text: string;
+    path: string[];
+}
+/** Immutable snapshot of the document's semantic structure. */
+export interface SemanticDocumentSnapshot {
+    schemaVersion: number;
+    documentId: string;
+    text: string;
+    outline: DocumentOutlineItem[];
+    nodes: SemanticNode[];
+}
+/** Non-fatal warning produced during an operation. */
+export type OasisWarning = {
+    code: string;
+    message: string;
+    nodeId?: string;
+};
+/** Error codes for operation failures. */
+export type OasisErrorCode = "NODE_NOT_FOUND" | "AMBIGUOUS_SELECTOR" | "INVALID_RANGE" | "VALIDATION_FAILED" | "READ_ONLY" | "UNSUPPORTED_OPERATION" | "DOCUMENT_VERSION_CONFLICT" | "IMPORT_FAILED" | "EXPORT_FAILED" | "ABORTED";
+/** Structured error information returned on operation failure. */
+export interface OasisError {
+    code: OasisErrorCode;
+    message: string;
+    expectedVersion?: number;
+    actualVersion?: number;
+    details?: unknown;
+}
+/**
+ * Wraps a successful value or an error with its metadata.
+ * @typeParam T - The type of the success value.
+ */
+export type OasisResult<T> = {
+    ok: true;
+    value: T;
+    version: number;
+    warnings: OasisWarning[];
+} | {
+    ok: false;
+    error: OasisError;
+};
+/** A single edit operation to be applied to the document. */
+export type EditOperation = {
+    op: "insertText";
+    target: DocumentSelector;
+    text: string;
+    offset?: number;
+} | {
+    op: "replaceText";
+    target: DocumentSelector;
+    text: string;
+} | {
+    op: "deleteRange";
+    range: DocumentRange;
+} | {
+    op: "insertParagraph";
+    text?: string;
+    after?: DocumentSelector;
+} | {
+    op: "insertBlocks";
+    blocks: EditorBlockNode[];
+    after?: DocumentSelector;
+} | {
+    op: "deleteNode";
+    target: DocumentSelector;
+} | {
+    op: "setTextStyle";
+    target: DocumentSelector;
+    style: EditorTextStyle;
+} | {
+    op: "setParagraphStyle";
+    target: DocumentSelector;
+    style: {
+        styleId: string;
+    };
+} | {
+    op: "insertTable";
+    rows: string[][];
+    after?: DocumentSelector;
+} | {
+    op: "updateTableCell";
+    target: {
+        tableId: string;
+        row: number;
+        column: number;
+    };
+    text: string;
+};
+/** Describes the origin/actor of an edit request. */
+export interface EditActor {
+    type: string;
+    actorId?: string;
+    label?: string;
+}
+/** Request to apply one or more edit operations to the document. */
+export interface ApplyEditRequest {
+    operations: EditOperation[];
+    expectedVersion?: number;
+    transactionId?: string;
+    idempotencyKey?: string;
+    origin?: EditActor;
+}
+/** Result value returned after applying edit operations. */
+export interface ApplyEditValue {
+    changedNodeIds: string[];
+    createdNodeIds: string[];
+}
+/**
+ * Deep-clones a document.
+ * @param document - The document to clone.
+ * @returns A deep copy of the document.
+ */
+export declare function cloneDocument<T extends EditorDocument>(document: T): T;
+/**
+ * Ensures the document has a schemaVersion property set.
+ * @param document - The document to normalize.
+ * @returns The normalized document.
+ */
+export declare function normalizeDocument(document: EditorDocument): EditorDocument;
+/**
+ * Validates document structure, returning errors if any.
+ * @param document - The document to validate.
+ * @returns An OasisResult indicating success or listing validation errors.
+ */
+export declare function validateDocument(document: EditorDocument): OasisResult<true>;
+/**
+ * Creates a new empty editor document.
+ * @param options - Optional initial blocks and title.
+ * @returns A new EditorDocument.
+ */
+export declare function createDocument(options?: {
+    blocks?: EditorBlockNode[];
+    title?: string;
+}): EditorDocument;
+/** Creates an empty paragraph node. Alias for {@link createEditorParagraph}. */
+export declare const createParagraph: typeof createEditorParagraph;
+/**
+ * Creates a heading paragraph.
+ * @param text - The heading text.
+ * @param options - Options including the heading level.
+ * @returns A new heading paragraph node.
+ */
+export declare function createHeading(text: string, options?: {
+    level?: number;
+}): EditorParagraphNode;
+/**
+ * Creates a table node from a 2D array of string cell values.
+ * @param rows - A 2D array where each inner array represents a row of cell values.
+ * @returns A new table node.
+ */
+export declare function createTable(rows: string[][]): ReturnType<typeof createEditorTable>;
+/**
+ * Creates a query object for read-only document inspection.
+ * @param document - The document to query against.
+ * @returns An object with snapshot, getText, getNode, find, and outline methods.
+ */
+export declare function queryDocument(document: EditorDocument): {
+    snapshot: () => SemanticDocumentSnapshot;
+    getText: (target?: DocumentSelector | DocumentRange) => string;
+    getNode: (selector: DocumentSelector) => SemanticNode | null;
+    find: (text: string) => DocumentMatch[];
+    outline: () => DocumentOutlineItem[];
+};
+/**
+ * Applies an array of edit operations to a document.
+ * @param document - The document to mutate.
+ * @param operations - The operations to apply.
+ * @returns The mutated document along with metadata about changed and created nodes.
+ */
+export declare function applyDocumentOperations(document: EditorDocument, operations: EditOperation[]): {
+    document: EditorDocument;
+    value: ApplyEditValue;
+};

package/dist/app/controllers/animationFrame.d.ts

@@ -0,0 +1,2 @@
+export declare function scheduleAnimationFrame(callback: () => void): number;
+export declare function cancelScheduledAnimationFrame(handle: number): void;