@opengeni/react 0.46.1 → 0.52.1

package/dist/components/artifacts/document-editor.d.ts

@@ -0,0 +1,172 @@
+import type { Document as ReferenceDocument, DocumentTextStyle as ReferenceDocumentTextStyle } from "@opengeni/artifact-tool/reference";
+import { type ReactNode } from "react";
+export type DocumentLayoutMode = "paginated" | "continuous";
+export type DocumentSelection = {
+    blockId: string;
+    start: number;
+    end: number;
+};
+export type DocumentCommit = {
+    kind: "text";
+    blockId: string;
+    text: string;
+    revision: string | number;
+} | {
+    kind: "format";
+    blockId: string;
+    range: {
+        start: number;
+        end: number;
+    };
+    style: Partial<ReferenceDocumentTextStyle>;
+    revision: string | number;
+} | {
+    kind: "insert-paragraph";
+    blockId: string;
+    revision: string | number;
+};
+export type DocumentCommitHandler = ((commit: DocumentCommit) => void) | ((commit: DocumentCommit) => Promise<void>);
+export type DocumentProjectionPageGeometry = Readonly<{
+    widthPt: number;
+    heightPt: number;
+    marginTopPt: number;
+    marginRightPt: number;
+    marginBottomPt: number;
+    marginLeftPt: number;
+    headerPt?: number;
+    footerPt?: number;
+    gutterPt?: number;
+}>;
+export type DocumentProjectionTextStyle = Readonly<{
+    fontFamily?: string;
+    fontSizePt?: number;
+    color?: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+}>;
+export type DocumentProjectionParagraphStyle = Readonly<{
+    headingLevel?: 1 | 2 | 3 | 4 | 5 | 6;
+    alignment?: "left" | "center" | "right" | "justify";
+    spaceBeforePt?: number;
+    spaceAfterPt?: number;
+    lineHeight?: number;
+    keepNext?: boolean;
+    pageBreakBefore?: boolean;
+    list?: Readonly<{
+        kind: "bullet" | "number";
+        level?: number;
+        instanceId?: string;
+    }>;
+}>;
+export type DocumentProjectionTextRun = Readonly<{
+    text: string;
+    style?: DocumentProjectionTextStyle;
+}>;
+export type DocumentProjectionParagraph = Readonly<{
+    kind: "paragraph";
+    id: string;
+    runs: readonly DocumentProjectionTextRun[];
+    style?: DocumentProjectionParagraphStyle;
+}>;
+export type DocumentProjectionTable = Readonly<{
+    kind: "table";
+    id: string;
+    rows: readonly (readonly (readonly DocumentProjectionTextRun[])[])[];
+    style?: Readonly<{
+        widthPt?: number;
+        columnWidthsPt?: readonly number[];
+        headerRows?: number;
+        cellPaddingPt?: number;
+        borderColor?: string;
+        headerFill?: string;
+        allowRowSplit?: boolean;
+    }>;
+}>;
+export type DocumentProjectionPageBreak = Readonly<{
+    kind: "pageBreak";
+    id: string;
+}>;
+export type DocumentProjectionBlock = DocumentProjectionParagraph | DocumentProjectionTable | DocumentProjectionPageBreak;
+export type DocumentProjectionSection = Readonly<{
+    id: string;
+    startBlockIndex: number;
+    page: DocumentProjectionPageGeometry;
+    titlePage?: boolean;
+    headerBlockCounts?: readonly [number, number, number];
+    footerBlockCounts?: readonly [number, number, number];
+}>;
+export type DocumentProjectionComment = Readonly<{
+    id: string;
+    blockId: string;
+    start: number;
+    end: number;
+    resolved: boolean;
+    replies: readonly Readonly<{
+        author: string;
+        text: string;
+        createdAt: string;
+    }>[];
+}>;
+export type DocumentProjectionChange = Readonly<{
+    id: string;
+    blockId: string;
+    kind: "insert" | "delete";
+    start: number;
+    end: number;
+    author: string;
+    createdAt: string;
+}>;
+/** Immutable render/edit projection; canonical document state stays with the host. */
+export type DocumentEditorProjection = Readonly<{
+    revision: string | number;
+    page: DocumentProjectionPageGeometry;
+    blocks: readonly DocumentProjectionBlock[];
+    sections?: readonly DocumentProjectionSection[];
+    comments?: readonly DocumentProjectionComment[];
+    changes?: readonly DocumentProjectionChange[];
+}>;
+export type DocumentEditorProps = {
+    document: ReferenceDocument;
+    /** Controlled projection mode. Omit to let the editor own the toggle. */
+    layout?: DocumentLayoutMode | undefined;
+    defaultLayout?: DocumentLayoutMode | undefined;
+    onLayoutChange?: ((layout: DocumentLayoutMode) => void) | undefined;
+    onSelectionChange?: ((selection: DocumentSelection) => void) | undefined;
+    onCommit?: DocumentCommitHandler | undefined;
+    onCommandError?: ((error: Error) => void) | undefined;
+    readOnly?: boolean | undefined;
+    ariaLabel?: string | undefined;
+    viewportHeight?: number | undefined;
+    overscanPages?: number | undefined;
+    className?: string | undefined;
+};
+export type DocumentProjectionEditorProps = Omit<DocumentEditorProps, "document" | "onSelectionChange" | "onCommit"> & {
+    projection: DocumentEditorProjection;
+    commit?: DocumentCommitHandler | undefined;
+    onCommandError?: ((error: Error) => void) | undefined;
+    onSelectionChange?: ((selection: DocumentSelection) => void) | undefined;
+};
+export type DocumentProjectionArtifactSurfaceProps = Omit<DocumentProjectionEditorProps, "ariaLabel" | "className"> & {
+    title: string;
+    subtitle?: ReactNode | undefined;
+    busy?: boolean | undefined;
+    className?: string | undefined;
+    editorClassName?: string | undefined;
+};
+export type DocumentArtifactSurfaceProps = Omit<DocumentEditorProps, "ariaLabel" | "className"> & {
+    title: string;
+    subtitle?: ReactNode | undefined;
+    busy?: boolean | undefined;
+    className?: string | undefined;
+    editorClassName?: string | undefined;
+};
+/** Compatibility adapter for the public authoring model. */
+export declare function DocumentEditor(props: DocumentEditorProps): import("react").JSX.Element;
+/** Projection-first document editor with one async command boundary. */
+export declare function DocumentProjectionEditor({ projection, commit, onCommandError, onSelectionChange, readOnly, ...props }: DocumentProjectionEditorProps): import("react").JSX.Element;
+/** Artifact chrome plus the reusable document editor. */
+export declare function DocumentArtifactSurface({ document, title, subtitle, busy, className, editorClassName, ...editorProps }: DocumentArtifactSurfaceProps): import("react").JSX.Element;
+/** Artifact chrome over the projection-first document editor. */
+export declare function DocumentProjectionArtifactSurface({ projection, title, subtitle, busy, className, editorClassName, ...editorProps }: DocumentProjectionArtifactSurfaceProps): import("react").JSX.Element;

package/dist/components/artifacts/editable-artifact-ui.d.ts

@@ -0,0 +1,13 @@
+import type { EditableArtifactSession, EditableArtifactSyncView } from "@opengeni/sdk/editable-artifacts";
+export declare function useEditableArtifactView(session: EditableArtifactSession): EditableArtifactSyncView;
+/** Changes whenever the Worker-resident speculative projection may have changed. */
+export declare function editableArtifactProjectionKey(view: EditableArtifactSyncView): string;
+export declare function editableArtifactStatusLabel(view: EditableArtifactSyncView): string;
+/** Revoked read authority must hide any projection retained before invalidation. */
+export declare function editableArtifactAccessRevoked(view: EditableArtifactSyncView): boolean;
+export declare function EditableArtifactMessage({ title, detail, retry, }: {
+    title: string;
+    detail: string;
+    retry?: (() => void) | undefined;
+}): import("react").JSX.Element;
+export declare function asEditableArtifactError(cause: unknown, fallback: string): Error;

package/dist/components/artifacts/editable-artifact-workbench.d.ts

@@ -0,0 +1,49 @@
+import { type CreateBrowserEditableArtifactSessionOptions, type EditableArtifactBrowserRuntime, type EditableArtifactSession } from "@opengeni/sdk/editable-artifacts";
+import { type EditableDocumentArtifactSurfaceProps } from "./editable-document.js";
+import { type EditablePresentationArtifactSurfaceProps } from "./editable-presentation.js";
+import { type EditableSpreadsheetArtifactSurfaceProps } from "./editable-spreadsheet.js";
+export type EditableArtifactWorkbenchProps = Readonly<{
+    session: EditableArtifactSession;
+    document?: Omit<EditableDocumentArtifactSurfaceProps, "session">;
+    spreadsheet?: Omit<EditableSpreadsheetArtifactSurfaceProps, "session">;
+    presentation?: Omit<EditablePresentationArtifactSurfaceProps, "session">;
+}>;
+export type EditableArtifactWorkbenchHostProps = Omit<EditableArtifactWorkbenchProps, "session"> & Readonly<{
+    /**
+     * Complete identity of the browser session authority. Change this when the
+     * artifact, deployment, principal, or authorization epoch changes.
+     */
+    sessionKey: string;
+    /** Called for the active keyed lifecycle and again only after replacement or retry. */
+    createSession: () => EditableArtifactSession;
+}>;
+type DefaultBrowserArtifactTransport = Omit<NonNullable<CreateBrowserEditableArtifactSessionOptions["transport"]>, "apiKey" | "fetch" | "headers" | "webSocketFactory"> & Readonly<{
+    /** Static deployment auth headers; rotate authorizationEpoch when they change. */
+    headers?: Readonly<Record<string, string>>;
+}>;
+export type BrowserEditableArtifactWorkbenchOptions = Omit<CreateBrowserEditableArtifactSessionOptions, "runtime" | "storage" | "transport"> & Readonly<{
+    /** Default module Worker only; custom Worker hosts use EditableArtifactWorkbenchHost. */
+    runtime: Omit<EditableArtifactBrowserRuntime, "workerFactory">;
+    /** Default fetch/WebSocket only; static deployment auth headers are supported. */
+    transport?: DefaultBrowserArtifactTransport;
+}>;
+export type BrowserEditableArtifactWorkbenchProps = Omit<EditableArtifactWorkbenchProps, "session"> & Readonly<{
+    options: BrowserEditableArtifactWorkbenchOptions;
+}>;
+/**
+ * One modality-neutral SDK workbench. Embedding hosts keep one route/component;
+ * each artifact still renders through its complete first-party editor surface.
+ */
+export declare function EditableArtifactWorkbench({ session, document, spreadsheet, presentation, }: EditableArtifactWorkbenchProps): import("react").JSX.Element;
+/**
+ * Route/embed composition that owns exactly one SDK session. The host supplies
+ * the authenticated SDK factory; React guarantees replacement and teardown.
+ */
+export declare function EditableArtifactWorkbenchHost({ sessionKey, createSession, document, spreadsheet, presentation, }: EditableArtifactWorkbenchHostProps): import("react").JSX.Element;
+/**
+ * Complete default-browser composition for embedders: verified WASM Worker,
+ * durable IndexedDB state, authenticated live sync, teardown, and the matching
+ * first-party editor. Advanced/custom transports compose the lower-level host.
+ */
+export declare function BrowserEditableArtifactWorkbench({ options, document, spreadsheet, presentation, }: BrowserEditableArtifactWorkbenchProps): import("react").JSX.Element;
+export {};

package/dist/components/artifacts/editable-document.d.ts

@@ -0,0 +1,24 @@
+import { type EditableArtifactSession } from "@opengeni/sdk/editable-artifacts";
+import { type ReactNode } from "react";
+import { type DocumentCommitHandler, type DocumentEditorProjection, type DocumentProjectionArtifactSurfaceProps } from "./document-editor.js";
+export type EditableDocumentArtifactSurfaceProps = Omit<DocumentProjectionArtifactSurfaceProps, "projection" | "commit" | "readOnly" | "busy" | "subtitle"> & {
+    session: EditableArtifactSession;
+    subtitle?: ReactNode | undefined;
+    readOnly?: boolean | undefined;
+    /** Called only after the durable SDK command has been accepted locally. */
+    onCommit?: DocumentCommitHandler | undefined;
+};
+/**
+ * Durable document editor over the public SDK session. Canonical state and
+ * speculative replay remain Worker-owned; React receives bounded projections.
+ */
+export declare function EditableDocumentArtifactSurface({ session, title, subtitle, readOnly, onCommit, onCommandError, ...surfaceProps }: EditableDocumentArtifactSurfaceProps): import("react").JSX.Element;
+/** Deterministically composes summary/body/sections/review at one Worker revision. */
+export declare function composeDocumentEditorProjection(session: EditableArtifactSession): Promise<DocumentEditorProjection>;
+export declare function minimalUtf16TextEdit(before: string, after: string): {
+    range: {
+        start: number;
+        end: number;
+    };
+    replacement: string;
+} | null;

package/dist/components/artifacts/editable-presentation.d.ts

@@ -0,0 +1,24 @@
+import { type EditableArtifactSession, type PresentationArtifactEditorSceneNode, type PresentationArtifactRichText } from "@opengeni/sdk/editable-artifacts";
+import { type ReactNode } from "react";
+import { type PresentationCommitHandler, type PresentationEditorProjection, type PresentationProjectionArtifactSurfaceProps } from "./presentation-editor.js";
+export type EditablePresentationArtifactSurfaceProps = Omit<PresentationProjectionArtifactSurfaceProps, "projection" | "commit" | "readOnly" | "busy" | "subtitle"> & {
+    session: EditableArtifactSession;
+    subtitle?: ReactNode | undefined;
+    readOnly?: boolean | undefined;
+    /** Called only after the durable SDK command has been accepted locally. */
+    onCommit?: PresentationCommitHandler | undefined;
+};
+export type ComposedPresentationProjection = Readonly<{
+    projection: PresentationEditorProjection;
+    sceneNodes: ReadonlyMap<string, PresentationArtifactEditorSceneNode>;
+}>;
+/**
+ * Durable presentation editor over the public SDK. The Worker owns canonical
+ * state; React only receives bounded catalog and per-slide editor projections.
+ */
+export declare function EditablePresentationArtifactSurface({ session, title, subtitle, readOnly, onCommit, onCommandError, ...surfaceProps }: EditablePresentationArtifactSurfaceProps): import("react").JSX.Element;
+/** Builds a deterministic, bounded catalog + editor-slide projection at one revision. */
+export declare function composePresentationEditorProjection(session: EditableArtifactSession): Promise<ComposedPresentationProjection>;
+export declare function flattenPresentationRichText(text: PresentationArtifactRichText): string;
+/** Preserves unaffected run styles and paragraph alignment across one UTF-16 text edit. */
+export declare function replacePresentationRichText(richText: PresentationArtifactRichText, before: string, after: string): PresentationArtifactRichText;

package/dist/components/artifacts/editable-spreadsheet.d.ts

@@ -0,0 +1,32 @@
+import { type EditableArtifactSession, type EditableSpreadsheetSheetMetadata } from "@opengeni/sdk/editable-artifacts";
+import { type ReactNode } from "react";
+import { type SpreadsheetCommit, type SpreadsheetSelection, type SpreadsheetViewport } from "./spreadsheet-grid.js";
+export type EditableSpreadsheetGridProps = {
+    session: EditableArtifactSession;
+    sheet: EditableSpreadsheetSheetMetadata;
+    metadataRevision: bigint;
+    readOnly?: boolean | undefined;
+    rowCount?: number | undefined;
+    columnCount?: number | undefined;
+    overscanRows?: number | undefined;
+    overscanColumns?: number | undefined;
+    onSelectionChange?: ((selection: SpreadsheetSelection) => void) | undefined;
+    onCommit?: ((commit: SpreadsheetCommit) => void) | undefined;
+    onCommandError?: ((error: Error) => void) | undefined;
+    onViewportChange?: ((viewport: SpreadsheetViewport) => void) | undefined;
+    className?: string | undefined;
+};
+export type EditableSpreadsheetArtifactSurfaceProps = Omit<EditableSpreadsheetGridProps, "metadataRevision" | "sheet"> & {
+    title?: string | undefined;
+    subtitle?: ReactNode | undefined;
+    actions?: ReactNode | undefined;
+    initialSheetId?: string | undefined;
+    allowAddSheet?: boolean | undefined;
+};
+/**
+ * Durable spreadsheet editor over one SDK session. Canonical state remains in
+ * the dedicated Worker; React receives one bounded immutable viewport only.
+ */
+export declare function EditableSpreadsheetGrid({ session, sheet, metadataRevision, readOnly, rowCount: requestedRowCount, columnCount: requestedColumnCount, overscanRows, overscanColumns, onSelectionChange, onCommit, onCommandError, onViewportChange, className, }: EditableSpreadsheetGridProps): import("react").JSX.Element;
+/** Artifact chrome, sheet navigation, and one Worker-backed spreadsheet grid. */
+export declare function EditableSpreadsheetArtifactSurface({ session, title, subtitle, actions, initialSheetId, allowAddSheet, readOnly, ...gridProps }: EditableSpreadsheetArtifactSurfaceProps): import("react").JSX.Element;

package/dist/components/artifacts/index.d.ts

@@ -0,0 +1,8 @@
+export { ArtifactSurface, type ArtifactModality, type ArtifactSurfaceProps, } from "./artifact-surface.js";
+export { SpreadsheetArtifactSurface, SpreadsheetGrid, SpreadsheetProjectionGrid, type SpreadsheetArtifactSurfaceProps, type SpreadsheetCommit, type SpreadsheetRangeCommit, type SpreadsheetGridProps, type SpreadsheetGridProjection, type SpreadsheetProjectionCell, type SpreadsheetProjectionGridProps, type SpreadsheetSelection, type SpreadsheetViewport, } from "./spreadsheet-grid.js";
+export { EditableSpreadsheetArtifactSurface, EditableSpreadsheetGrid, type EditableSpreadsheetArtifactSurfaceProps, type EditableSpreadsheetGridProps, } from "./editable-spreadsheet.js";
+export { BrowserEditableArtifactWorkbench, EditableArtifactWorkbench, EditableArtifactWorkbenchHost, type BrowserEditableArtifactWorkbenchOptions, type BrowserEditableArtifactWorkbenchProps, type EditableArtifactWorkbenchHostProps, type EditableArtifactWorkbenchProps, } from "./editable-artifact-workbench.js";
+export { EditableDocumentArtifactSurface, type EditableDocumentArtifactSurfaceProps, } from "./editable-document.js";
+export { DocumentArtifactSurface, DocumentEditor, DocumentProjectionArtifactSurface, DocumentProjectionEditor, type DocumentArtifactSurfaceProps, type DocumentCommit, type DocumentCommitHandler, type DocumentEditorProps, type DocumentEditorProjection, type DocumentLayoutMode, type DocumentProjectionArtifactSurfaceProps, type DocumentProjectionBlock, type DocumentProjectionChange, type DocumentProjectionComment, type DocumentProjectionEditorProps, type DocumentProjectionPageBreak, type DocumentProjectionPageGeometry, type DocumentProjectionParagraph, type DocumentProjectionParagraphStyle, type DocumentProjectionSection, type DocumentProjectionTable, type DocumentProjectionTextRun, type DocumentProjectionTextStyle, type DocumentSelection, } from "./document-editor.js";
+export { EditablePresentationArtifactSurface, type EditablePresentationArtifactSurfaceProps, } from "./editable-presentation.js";
+export { PresentationArtifactSurface, PresentationEditor, PresentationProjectionArtifactSurface, PresentationProjectionEditor, type PresentationArtifactSurfaceProps, type PresentationCommit, type PresentationCommitHandler, type PresentationEditorProps, type PresentationEditorProjection, type PresentationProjectionArtifactSurfaceProps, type PresentationProjectionChart, type PresentationProjectionChartSeries, type PresentationProjectionConnector, type PresentationProjectionEditorProps, type PresentationProjectionElementMetadata, type PresentationProjectionElement, type PresentationProjectionFill, type PresentationProjectionGroup, type PresentationProjectionImage, type PresentationProjectionLine, type PresentationProjectionPosition, type PresentationProjectionRichText, type PresentationProjectionShape, type PresentationProjectionTable, type PresentationProjectionTableCell, type PresentationProjectionTextParagraph, type PresentationProjectionTextRun, type PresentationProjectionTextStyle, type PresentationSlideProjection, } from "./presentation-editor.js";

package/dist/components/artifacts/presentation-editor.d.ts

@@ -0,0 +1,297 @@
+import { type ReactNode } from "react";
+import type { Presentation, PresentationElement, PresentationPosition, Slide } from "@opengeni/artifact-tool/reference";
+type PresentationObject = PresentationElement;
+export type PresentationCommit = {
+    kind: "slide-insert";
+    slideId: string;
+    index: number;
+    revision?: string | number;
+} | {
+    kind: "slide-delete";
+    slideId: string;
+    index: number;
+    revision?: string | number;
+} | {
+    kind: "object-insert";
+    slideId: string;
+    objectId: string;
+    index: number;
+    position: PresentationPosition;
+    revision?: string | number;
+} | {
+    kind: "object-delete";
+    slideId: string;
+    objectId: string;
+    revision?: string | number;
+} | {
+    kind: "move" | "resize";
+    slideId: string;
+    objectId: string;
+    before: PresentationPosition;
+    after: PresentationPosition;
+    revision?: string | number;
+} | {
+    kind: "text";
+    slideId: string;
+    objectId: string;
+    before: string;
+    after: string;
+    revision?: string | number;
+};
+export type PresentationCommitHandler = ((commit: PresentationCommit) => void) | ((commit: PresentationCommit) => Promise<void>);
+export type PresentationProjectionPosition = Readonly<{
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}>;
+export type PresentationProjectionFill = string | Readonly<{
+    type?: "solid";
+    color: string;
+}>;
+export type PresentationProjectionLine = Readonly<{
+    style?: "solid" | "dash" | "dot" | "none";
+    fill?: PresentationProjectionFill;
+    width?: number;
+}>;
+export type PresentationProjectionTextStyle = Readonly<{
+    fontFamily?: string;
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    color?: string;
+    alignment?: "left" | "center" | "right" | "justify";
+    verticalAlignment?: "top" | "middle" | "bottom";
+}>;
+export type PresentationProjectionTextRun = Readonly<{
+    text: string;
+    style: PresentationProjectionTextStyle;
+    language?: string | null;
+}>;
+export type PresentationProjectionTextParagraph = Readonly<{
+    runs: readonly PresentationProjectionTextRun[];
+    alignment: "left" | "center" | "right" | "justify";
+}>;
+export type PresentationProjectionRichText = Readonly<{
+    paragraphs: readonly PresentationProjectionTextParagraph[];
+    verticalAlignment: "top" | "middle" | "bottom";
+}>;
+export type PresentationProjectionElementMetadata = Readonly<{
+    nodeSource?: Readonly<{
+        kind: "master" | "layout" | "slide";
+        id: string;
+    }>;
+    inherited?: boolean;
+    parentId?: string | null;
+    order?: number;
+    /** Inherited master/layout nodes remain visible but cannot be edited in slide mode. */
+    readOnly?: boolean;
+}>;
+export type PresentationProjectionShape = Readonly<{
+    kind: "shape";
+    id: string;
+    name: string;
+    geometry: "textbox" | "rect" | "roundRect" | "ellipse" | "triangle" | "rightArrow" | "line";
+    position: PresentationProjectionPosition;
+    fill?: PresentationProjectionFill;
+    line?: PresentationProjectionLine;
+    rotation?: number;
+    borderRadius?: number | string;
+    text: string;
+    textStyle?: PresentationProjectionTextStyle;
+    richText?: PresentationProjectionRichText;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionChartSeries = Readonly<{
+    name: string;
+    categories?: readonly string[];
+    values: readonly number[];
+    xValues?: readonly number[];
+    bubbleSizes?: readonly number[];
+    fill?: PresentationProjectionFill;
+    line?: PresentationProjectionLine;
+}>;
+export type PresentationProjectionChart = Readonly<{
+    kind: "chart";
+    id: string;
+    name: string;
+    type: "bar" | "line" | "area" | "pie" | "doughnut" | "scatter" | "bubble" | "radar";
+    position: PresentationProjectionPosition;
+    title?: string;
+    titleRichText?: PresentationProjectionRichText;
+    hasLegend?: boolean;
+    series: readonly PresentationProjectionChartSeries[];
+    xAxis?: Readonly<{
+        visible?: boolean;
+        title?: string;
+        min?: number;
+        max?: number;
+    }>;
+    yAxis?: Readonly<{
+        visible?: boolean;
+        title?: string;
+        min?: number;
+        max?: number;
+    }>;
+    dataLabels?: Readonly<{
+        showValue?: boolean;
+        showSeriesName?: boolean;
+        showCategoryName?: boolean;
+        showPercent?: boolean;
+        position?: "center" | "inEnd" | "outEnd";
+    }>;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionImage = Readonly<{
+    kind: "image";
+    id: string;
+    name: string;
+    position: PresentationProjectionPosition;
+    /** Host-resolved data/blob/same-origin URL. Arbitrary remote URLs are ignored. */
+    source?: string;
+    alt?: string;
+    prompt?: string;
+    fit?: "contain" | "cover";
+    crop?: Readonly<{
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }>;
+    geometry?: "rect" | "roundRect" | "ellipse";
+    borderRadius?: number | string;
+    rotation?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    digest?: string;
+    contentType?: string;
+    intrinsicWidth?: number;
+    intrinsicHeight?: number;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionTableCell = Readonly<{
+    text: string;
+    richText?: PresentationProjectionRichText;
+    fill?: PresentationProjectionFill;
+    textStyle?: PresentationProjectionTextStyle;
+    rowSpan?: number;
+    colSpan?: number;
+}>;
+export type PresentationProjectionTable = Readonly<{
+    kind: "table";
+    id: string;
+    name: string;
+    position: PresentationProjectionPosition;
+    rows: readonly (readonly (PresentationProjectionTableCell | null)[])[];
+    columnWidths?: readonly number[];
+    rowHeights?: readonly number[];
+    fill?: PresentationProjectionFill;
+    line?: PresentationProjectionLine;
+    textStyle?: PresentationProjectionTextStyle;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionGroup = Readonly<{
+    kind: "group";
+    id: string;
+    name: string;
+    position: PresentationProjectionPosition;
+    childOffset: Readonly<{
+        left: number;
+        top: number;
+    }>;
+    childExtent: Readonly<{
+        width: number;
+        height: number;
+    }>;
+    rotation?: number;
+    flipHorizontal?: boolean;
+    flipVertical?: boolean;
+    children: readonly PresentationProjectionElement[];
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionConnector = Readonly<{
+    kind: "connector";
+    id: string;
+    name: string;
+    connectorKind: "straight" | "elbow" | "curved";
+    position: PresentationProjectionPosition;
+    start: Readonly<{
+        nodeId: string | null;
+        x: number;
+        y: number;
+    }>;
+    end: Readonly<{
+        nodeId: string | null;
+        x: number;
+        y: number;
+    }>;
+    line?: PresentationProjectionLine;
+}> & PresentationProjectionElementMetadata;
+export type PresentationProjectionElement = PresentationProjectionShape | PresentationProjectionChart | PresentationProjectionImage | PresentationProjectionTable | PresentationProjectionGroup | PresentationProjectionConnector;
+export type PresentationSlideProjection = Readonly<{
+    id: string;
+    title?: string;
+    background?: PresentationProjectionFill;
+    elements: readonly PresentationProjectionElement[];
+    layout?: Readonly<{
+        id: string;
+        name: string;
+        masterId: string | null;
+        background: PresentationProjectionFill;
+    }> | null;
+    notes?: PresentationProjectionRichText | null;
+}>;
+/** Immutable render/edit projection; the host keeps the canonical deck off the React thread. */
+export type PresentationEditorProjection = Readonly<{
+    revision: string | number;
+    slideSize: Readonly<{
+        width: number;
+        height: number;
+    }>;
+    slides: readonly PresentationSlideProjection[];
+}>;
+export type PresentationProjectionEditorProps = Omit<PresentationEditorProps, "presentation" | "revision" | "onSlideChange" | "onSelectionChange" | "onCommit"> & {
+    projection: PresentationEditorProjection;
+    commit?: PresentationCommitHandler | undefined;
+    onCommandError?: ((error: Error) => void) | undefined;
+    onSlideChange?: ((slide: PresentationSlideProjection, index: number) => void) | undefined;
+    onSelectionChange?: ((object: PresentationProjectionElement | null, slide: PresentationSlideProjection) => void) | undefined;
+};
+export type PresentationProjectionArtifactSurfaceProps = PresentationProjectionEditorProps & {
+    title?: string | undefined;
+    subtitle?: ReactNode | undefined;
+    actions?: ReactNode | undefined;
+    busy?: boolean | undefined;
+};
+export type PresentationEditorProps = {
+    presentation: Presentation;
+    /** Increment/change after a host applies an out-of-band model mutation. */
+    revision?: string | number | undefined;
+    activeSlideId?: string | undefined;
+    defaultActiveSlideId?: string | undefined;
+    selectedObjectId?: string | null | undefined;
+    defaultSelectedObjectId?: string | null | undefined;
+    zoom?: number | undefined;
+    defaultZoom?: number | undefined;
+    readOnly?: boolean | undefined;
+    className?: string | undefined;
+    onSlideChange?: ((slide: Slide, index: number) => void) | undefined;
+    onSelectionChange?: ((object: PresentationObject | null, slide: Slide) => void) | undefined;
+    onCommit?: PresentationCommitHandler | undefined;
+    onCommandError?: ((error: Error) => void) | undefined;
+    onZoomChange?: ((zoom: number) => void) | undefined;
+};
+export type PresentationArtifactSurfaceProps = PresentationEditorProps & {
+    title?: string | undefined;
+    subtitle?: ReactNode | undefined;
+    actions?: ReactNode | undefined;
+    busy?: boolean | undefined;
+};
+/** Compatibility adapter for the public authoring model. */
+export declare function PresentationEditor(props: PresentationEditorProps): import("react").JSX.Element;
+/**
+ * Projection-first editor. It creates only a disposable render view; all
+ * durable mutations leave through the async command port.
+ */
+export declare function PresentationProjectionEditor({ projection, commit, onCommandError, onSlideChange, onSelectionChange, readOnly, ...props }: PresentationProjectionEditorProps): import("react").JSX.Element;
+/** Artifact chrome plus the editor, for drop-in SDK embedding. */
+export declare function PresentationArtifactSurface({ presentation, title, subtitle, actions, busy, className, ...editorProps }: PresentationArtifactSurfaceProps): import("react").JSX.Element;
+/** Artifact chrome over the projection-first editor. */
+export declare function PresentationProjectionArtifactSurface({ projection, title, subtitle, actions, busy, className, ...editorProps }: PresentationProjectionArtifactSurfaceProps): import("react").JSX.Element;
+export {};