@mrakomor/core 0.0.11 → 0.0.13

package/dist/types/schema/blockContent.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Schema for one inline style range: `{ length, offset, style }`.
+ * @returns {*} `@esmj/schema` object schema
+ */
+export function inlineStyleRangeSchema(): any;
+/**
+ * One entity range: `{ entity: { type, data }, length, offset }`.
+ *
+ * @param {import('#src/types.mjs').EntityRangeSchemaOptions} [options]
+ */
+export function entityRangeSchema({ type, data, length, offset, }?: import("#src/types.mjs").EntityRangeSchemaOptions): import("@esmj/schema").ObjectSchemaInterface<{
+    entity: import("@esmj/schema").SchemaInterface<{
+        type: string;
+        data: unknown;
+    }, {
+        type: string;
+        data: unknown;
+    }>;
+    length: import("@esmj/schema").NumberSchemaInterface;
+    offset: import("@esmj/schema").NumberSchemaInterface;
+}>;
+/**
+ * `entityRanges` array that keeps only `atom.tts.Voice` entries.
+ * @returns {*} `@esmj/schema` array schema
+ */
+export function ttsVoiceEntityRangesSchema(): any;
+/**
+ * Shared `{ component, componentId, properties, settings }` block envelope.
+ *
+ * @param {Element | null | undefined} node HTML used to seed `componentId` / text defaults
+ * @param {import('#src/types.mjs').BlockStateSchemaSpec} spec
+ * @returns {*} `@esmj/schema` object schema
+ */
+export function blockStateSchema(node: Element | null | undefined, { component, properties, settings }: import("#src/types.mjs").BlockStateSchemaSpec): any;

package/dist/types/schema/blockRegister.d.mts

@@ -0,0 +1,14 @@
+/**
+ * Stable register id for a block entry (`block:{NAMESPACE}` or list variants).
+ * @param {string} namespace
+ * @param {object | undefined} settings
+ * @returns {string}
+ */
+export function blockRegistrationId(namespace: string, settings: object | undefined): string;
+/**
+ * Parse one block register entry (constructor or registration object).
+ * @param {import('#src/types.mjs').BlockConstructor | import('#src/types.mjs').BlockComponentRegistration} entry
+ * @param {number} [index]
+ * @returns {import('#src/types.mjs').BlockComponentRegistration}
+ */
+export function blockComponentRegistrationSchema(entry: import("#src/types.mjs").BlockConstructor | import("#src/types.mjs").BlockComponentRegistration, index?: number): import("#src/types.mjs").BlockComponentRegistration;

package/dist/types/schema/config.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Public `createMrakomor(config)` input. Call `.parse(config)` to throw on invalid values.
+ * Parse for validation only — merge the original `config` afterward so unknown keys are kept.
+ * @returns {*} `@esmj/schema` object schema
+ */
+export function createMrakomorConfigSchema(): any;

package/dist/types/types.d.mts

@@ -0,0 +1,636 @@
+/**
+ * `@esmj/signals` state cell.
+ */
+export type Signal<T> = import("@esmj/signals").Signal<T>;
+/**
+ * Signal-shaped DOM ref returned by `@esmj/dom` `useRef()`.
+ */
+export type ElementRef<ElementType extends HTMLElement = HTMLElement> = {
+    get: () => ElementType | null;
+    set: (arg0: ElementType | null) => ElementType | null;
+    current: ElementType | null;
+};
+/**
+ * One inline style span on block (or list-item) text.
+ */
+export type InlineStyleRange = {
+    offset: number;
+    length: number;
+    style: string;
+};
+/**
+ * One entity span (`atom.link.Link`, `atom.tts.Voice`, …).
+ */
+export type EntityRange = {
+    entity: {
+        type: string;
+        data: any;
+    };
+    offset: number;
+    length: number;
+};
+/**
+ * Entity range accepted before its schema fills defaults.
+ */
+export type EntityRangeInput = {
+    entity: {
+        type: string;
+        data?: any;
+    };
+    offset?: number | undefined;
+    length?: number | undefined;
+};
+/**
+ * Character range relative to a selectable root.
+ */
+export type RangeMeta = {
+    offset: number;
+    length: number;
+};
+/**
+ * A `[SELECTABLE_ELEMENT]`-marked DOM element resolved from a `Range`, plus
+ * its index among its root's selectable items. See `dom.mjs`'s
+ * `getSelectableElementsInBlock` / `getSelectableItemForRange`.
+ */
+export type SelectableItem = {
+    element: Element;
+    index: number;
+};
+/**
+ * CMS block envelope. `properties` / `settings` depend on `component`.
+ */
+export type BlockState<Properties = Record<string, any>, Settings = Record<string, any>> = {
+    /**
+     * dotted NAMESPACE
+     */
+    component: string;
+    componentId: string;
+    properties: Properties;
+    settings: Settings;
+};
+/**
+ * Block accepted before `normalizeComponentState()` fills schema defaults.
+ */
+export type BlockStateInput = {
+    /**
+     * dotted NAMESPACE
+     */
+    component: string;
+    componentId?: string | undefined;
+    properties?: Record<string, any> | undefined;
+    settings?: Record<string, any> | undefined;
+};
+export type ComponentStateInput = BlockStateInput | EntityRangeInput;
+export type ComponentState = BlockState | EntityRange;
+/**
+ * Generic cross-component conversion shape used by
+ * `BlockConstructor.toExchangeState` / `fromExchangeState`. `properties.items`
+ * ({@link ExchangeItem}[]) is the ONLY text-shaped field — every block type
+ * (flat text blocks like Paragraph/Headline, or multi-row blocks like List)
+ * produces/consumes the same `items[]` array, one entry per selectable item
+ * (a flat block always has exactly one). This lets transform/merge/footer
+ * text-count/formatting-resolution share one generic implementation instead
+ * of each block having its own flat-vs-list special case.
+ * Contract: each item's `text` (when present) is always DOM-sentinel-free —
+ * every `toExchangeState` implementation normalizes it via
+ * `normalizeBlockText` before returning, so callers never need to
+ * re-normalize a `toExchangeState()` result.
+ */
+export type ExchangeBlockState = {
+    properties: {
+        items: ExchangeItem[];
+    } & Record<string, any>;
+    settings?: Record<string, any> | undefined;
+    /**
+     * current/target component namespace for this exchange state (e.g. clipboard wraps a list item's shape as PARAGRAPH_NAMESPACE)
+     */
+    component?: string | undefined;
+    /**
+     * component namespace this exchange state was produced FROM (set by toExchangeState producers); lets fromExchangeState implementations make origin-aware decisions
+     */
+    originComponent?: string | undefined;
+};
+/**
+ * One row of `ExchangeBlockState.properties.items` — a flat text block has
+ * exactly one, a List has one per `<li>`. This is an OPEN bag (like
+ * `ExchangeBlockState.properties`): the well-known keys below cover every
+ * block today, but a block's own `toExchangeState` override may add whatever
+ * extra keys it needs (e.g. a future richer block type) — do not treat this
+ * as a sealed shape.
+ */
+export type ExchangeItem = {
+    text?: string | undefined;
+    inlineStyleRanges?: InlineStyleRange[] | undefined;
+    entityRanges?: EntityRange[] | undefined;
+    /**
+     * nesting level (List only; default 0, ignored by flat blocks)
+     */
+    depth?: number | undefined;
+    /**
+     * stable per-item DOM identity (List only); lets `patchBlockExchangeItem`'s `fromExchangeState` round-trip avoid minting new ids on every keystroke
+     */
+    componentId?: string | undefined;
+};
+/**
+ * Paragraph / headline `properties`.
+ */
+export type TextBlockProperties = {
+    text: string;
+    inlineStyleRanges: InlineStyleRange[];
+    entityRanges: EntityRange[];
+};
+export type TextBlockState = BlockState<TextBlockProperties>;
+/**
+ * Minimal text/range state accepted by rich-text helpers.
+ */
+export type RichTextState = {
+    component?: string | undefined;
+    componentId?: string | undefined;
+    properties: TextBlockProperties;
+    settings?: Record<string, any> | undefined;
+};
+/**
+ * One list row.
+ */
+export type ListItem = {
+    componentId: string;
+    depth: number;
+    text: string;
+    inlineStyleRanges: InlineStyleRange[];
+    entityRanges: EntityRange[];
+};
+export type ListBlockProperties = {
+    items: ListItem[];
+};
+export type ListBlockState = BlockState<ListBlockProperties, {
+    style: "ORDERED" | "UNORDERED";
+}>;
+/**
+ * Minimal schema contract used by component constructors.
+ */
+export type Schema<Output> = {
+    parse: (...args: any[]) => Output;
+};
+/**
+ * Inline-style class used to build and parse rich text.
+ */
+export type InlineStyleConstructor = Function & {
+    style: string;
+    match: (arg0: any) => boolean;
+};
+/**
+ * Entity-range class used to build and parse rich text.
+ */
+export type EntityRangeConstructor = Function & {
+    NAMESPACE: string;
+    match: (arg0: any) => boolean;
+    getStateSchema: (...args: any[]) => Schema<EntityRange>;
+};
+/**
+ * Inline-style and entity-range constructors used to build/parse rich text.
+ */
+export type RichTextComponents = {
+    inlineStyleComponents: InlineStyleConstructor[];
+    entityRangeComponents: EntityRangeConstructor[];
+};
+/**
+ * Tooltip actions declared on a block type.
+ */
+export type TooltipConfig = {
+    inlineStyles: string[];
+    entityRanges: string[];
+    blockTransforms: string[];
+};
+/**
+ * Any class/function component resolvable by a plugin.
+ */
+export type ComponentConstructor = Function & {
+    NAMESPACE: string;
+    LABEL?: string | Function;
+    getStateSchema?: (...args: any[]) => Schema<any>;
+};
+/**
+ * Content block class (`Paragraph`, `List`, …).
+ */
+export type BlockConstructor = Function & {
+    NAMESPACE: string;
+    LABEL?: string | Function;
+    getStateSchema: (...args: any[]) => Schema<BlockState>;
+    toExchangeState: (arg0: BlockState) => ExchangeBlockState;
+    fromExchangeState: (arg0: ExchangeBlockState) => BlockStateInput;
+    appendExchangeState: (arg0: BlockState, arg1: ExchangeBlockState) => ({
+        state: BlockState;
+        cursor: number;
+    } | null);
+};
+/**
+ * Content-editable block instance (`this` in Paragraph / List / Headline).
+ */
+export type BlockInstance = {
+    element: Element | null;
+    mrakomor: Mrakomor;
+    state: Signal<BlockState>;
+    constructor: Function;
+    getState: () => BlockState;
+    isStale: () => boolean;
+    isAtomic?: (() => boolean) | undefined;
+    setCursor?: ((arg0?: {
+        cursor?: number;
+        itemIndex?: number;
+    } | undefined) => void) | undefined;
+    onKeydown?: ((arg0: KeydownEvent) => void) | undefined;
+    getInlineStyleComponents?: (() => InlineStyleConstructor[]) | undefined;
+    getEntityRangeComponents?: (() => EntityRangeConstructor[]) | undefined;
+};
+/**
+ * Rich-text block instance accepted by DOM parse helpers.
+ */
+export type RichTextBlockInstance = BlockInstance & {
+    getInlineStyleComponents: () => InlineStyleConstructor[];
+    getEntityRangeComponents: () => EntityRangeConstructor[];
+};
+/**
+ * Display-only help dialog row (not executable; not in `register.slashActions`).
+ */
+export type HelpEntry = {
+    id: string;
+    group: string;
+    description: string;
+    commands?: string[] | undefined;
+    shortcuts?: string[] | undefined;
+};
+/**
+ * Core + plugin command methods on `mrakomor.command`.
+ */
+export type MrakomorCommand = {
+    insertBlockElement: (arg0: object | undefined, arg1: object | undefined) => void;
+    replaceBlockElement: (arg0: object | undefined, arg1: object | undefined) => void;
+    removeBlockElement: (arg0: object | undefined, arg1: object | undefined) => void;
+    mergeBlockElement: (arg0: object | undefined, arg1: object | undefined) => void;
+    transformBlockElement: (arg0: object | undefined, arg1: object | undefined) => void;
+    moveBlockElement: (arg0: object | undefined, arg1: object | undefined) => void;
+    insertEntityRange: (arg0: object | undefined, arg1: object | undefined) => void;
+    removeEntityRange: (arg0: object | undefined, arg1: object | undefined) => void;
+    insertInlineStyleRange: (arg0: object | undefined, arg1: object | undefined) => void;
+    copy?: ((arg0?: object | undefined) => void) | undefined;
+    cut?: ((arg0?: object | undefined) => void) | undefined;
+    paste?: ((arg0?: object | undefined) => void) | undefined;
+    openDialog?: ((arg0?: object | undefined, arg1?: object | undefined) => void) | undefined;
+    closeDialog?: (() => void) | undefined;
+    openTooltip?: ((arg0?: object | undefined, arg1?: object | undefined) => void) | undefined;
+    closeTooltip?: ((arg0?: object | undefined) => void) | undefined;
+    openMenu?: ((arg0?: object | undefined, arg1?: object | undefined) => void) | undefined;
+    updateMenu?: ((arg0?: object | undefined, arg1?: object | undefined) => void) | undefined;
+    closeMenu?: (() => void) | undefined;
+    openBlockInsertMenu?: ((arg0: {
+        blockElement: Element;
+        anchorRect: DOMRect;
+    }) => void) | undefined;
+    closeBlockInsertMenu?: (() => void) | undefined;
+    openHelp?: ((arg0?: object | undefined) => void) | undefined;
+};
+export type RegisterSubscription = {
+    unsubscribe: () => void;
+};
+/**
+ * Map-backed register base API (`Register` extends `@esmj/observable` `Observable`).
+ */
+export type RegisterApi = {
+    add: (arg0: any) => any | null | any[];
+    get: (arg0: string) => any | undefined;
+    has: (arg0: string) => boolean;
+    remove: (arg0: string) => boolean;
+    list: () => any[];
+    subscribe: (arg0: (arg0: any[]) => void) => RegisterSubscription;
+};
+/**
+ * Block register (`component/block/BlockRegister.mjs`).
+ */
+export type BlockRegister = RegisterApi & {
+    getByNamespace: (arg0: string) => BlockConstructor | undefined;
+};
+/**
+ * Slash action register (`plugin/slashCommand/SlashActionRegister.mjs`).
+ * Stored ids are bare slugs (e.g. `help`).
+ */
+export type SlashActionRegister = RegisterApi;
+/**
+ * Editor registries — constructed in `Mrakomor`; normalize on `add`.
+ */
+export type MrakomorRegister = {
+    blocks: BlockRegister;
+    /**
+     * Set by `slashCommandPlugin`
+     */
+    slashActions?: RegisterApi | undefined;
+    help: RegisterApi;
+};
+/**
+ * Editor instance plugins and blocks talk to.
+ */
+export type Mrakomor = {
+    command: MrakomorCommand;
+    register: MrakomorRegister;
+    emitter: import("@esmj/emitter").Emitter;
+    listenerAbortController: AbortController;
+    _id: string;
+    getConfig: () => MrakomorConfig;
+    getRoot: () => Element | null;
+    _getContentRoot: () => Element | null;
+    _setContentRoot: (arg0: Element | null) => void;
+    getContent: () => BlockState[];
+    setContent: (arg0: BlockStateInput[] | undefined) => void;
+    emit: (arg0: string, arg1: object | undefined) => EmitterEvent;
+    on: (arg0: string, arg1: (arg0: EmitterEvent) => void) => () => void;
+    onChangeContent: (arg0: (arg0: EmitterEvent) => void) => () => void;
+    emitDomEvent: (arg0: string, arg1: Event) => boolean;
+    wrapBlockElement: (arg0: any) => any;
+    mount: () => any;
+    unmount: () => void;
+    resolveComponent: (arg0: string, arg1: Signal<BlockState>) => any;
+    resolveComponentConstructor: (arg0: string) => ComponentConstructor | undefined;
+    normalizeComponentState: (arg0: ComponentStateInput) => ComponentState | undefined;
+    _getContentState: () => BlockState[];
+    _setContentState: (arg0: BlockState[] | undefined) => void;
+    _getBlockElements: () => Element[];
+    _syncBlockElementsFromDom: () => void;
+    _setBlockElement: (arg0: Element, arg1: number | undefined) => void;
+    _removeBlockElement: (arg0: Element) => void;
+    _getBlockElementIndex: (arg0: Element | null | undefined) => number;
+    _getBlockElementByComponentId: (arg0: string | null | undefined) => Element | null;
+    _getBlockElementState: (arg0: Element | null | undefined) => BlockState | undefined;
+    _onMount: () => void;
+    _onUnmount: () => void;
+    _init?: (() => void) | undefined;
+};
+/**
+ * Fully resolved editor config passed to plugins.
+ */
+export type MrakomorConfig = {
+    debug: boolean;
+    content: BlockStateInput[];
+    /**
+     * Always includes `dialogPlugin`, `menuPlugin`, and ends with `defaultMrakomorPlugin` (appended if missing). Add `footerPlugin` / `helpPlugin` from `@mrakomor/core/footer` and `@mrakomor/core/help` when needed.
+     */
+    plugins: PluginFactory[];
+    /**
+     * Normalized via `register.blocks` (`getConfig()` read-through).
+     */
+    blockComponents: BlockComponentRegistration[];
+    /**
+     * Normalized via `register.slashActions`; auto-synced to help.
+     */
+    slashActions?: SlashActionRegistration[] | undefined;
+    inlineStyles: InlineStyleConstructor[];
+    entityRanges: EntityRangeConstructor[];
+    tooltip: {
+        [x: string]: Partial<TooltipConfig>;
+    };
+    root: Element;
+    id?: string | undefined;
+};
+/**
+ * Public `createMrakomor()` configuration before defaults are applied.
+ * Validated by `createMrakomorConfigSchema()` in [`schema/config.mjs`](schema/config.mjs).
+ */
+export type CreateMrakomorConfig = {
+    root: Element;
+    id?: string | undefined;
+    debug?: boolean | undefined;
+    content?: BlockStateInput[] | undefined;
+    /**
+     * Always includes `dialogPlugin`, `menuPlugin`, and ends with `defaultMrakomorPlugin` (appended if missing). Add `footerPlugin` / `helpPlugin` from `@mrakomor/core/footer` and `@mrakomor/core/help` when needed.
+     */
+    plugins?: PluginFactory[] | undefined;
+    blockComponents?: (BlockConstructor | BlockComponentRegistration)[] | undefined;
+    slashActions?: SlashActionRegistration[] | undefined;
+    inlineStyles?: InlineStyleConstructor[] | undefined;
+    entityRanges?: EntityRangeConstructor[] | undefined;
+    tooltip?: {
+        [x: string]: Partial<TooltipConfig>;
+    } | undefined;
+};
+/**
+ * Registered block in `config.blockComponents` (register + resolve). Normalized id: `block:{NAMESPACE}` or `block:{NAMESPACE}:ul|ol`.
+ */
+export type BlockComponentRegistration = {
+    component: BlockConstructor;
+    id: string;
+    label: string;
+    keywords: string[];
+    group: string;
+    order?: number | undefined;
+    settings?: object | undefined;
+};
+/**
+ * Non-block slash menu entry (`config.slashActions`). Invoked via `handler(ctx)`.
+ */
+export type SlashActionRegistration = {
+    /**
+     * Stable id (bare slug after normalize, e.g. `help`)
+     */
+    id: string;
+    label: string;
+    keywords: string[];
+    /**
+     * Help dialog section (auto-synced from slashActions)
+     */
+    group: string;
+    order?: number | undefined;
+    /**
+     * Optional; shown in help dialog
+     */
+    description?: string | undefined;
+    handler: (arg0: SlashCommandContext) => void;
+};
+/**
+ * Slash menu row: block insert/replace or non-block action.
+ */
+export type SlashMenuEntry = BlockComponentRegistration | SlashActionRegistration;
+/**
+ * Context for slash apply helpers.
+ */
+export type SlashCommandContext = {
+    mrakomor: Mrakomor;
+    blockElement: Element;
+    query: string;
+    slashStart: number;
+    slashEnd: number;
+    /**
+     * Block snapshot at `/` (through `/`; query is DOM-only until apply)
+     */
+    baselineState: BlockState | null | undefined;
+    range: Range | null;
+};
+/**
+ * Active slash session offsets (plugin-private).
+ */
+export type SlashSession = {
+    blockElement: Element;
+    slashStart: number;
+    slashEnd: number;
+    query: string;
+    baselineState?: BlockState | null | undefined;
+};
+/**
+ * Factory argument: `plugin({ config, root, mrakomor })`.
+ */
+export type PluginContext = {
+    config: MrakomorConfig;
+    root: Element;
+    mrakomor: Mrakomor;
+};
+/**
+ * Plugin instance. Every hook is optional.
+ */
+export type Plugin = {
+    resolveConfig?: ((arg0: MrakomorConfig) => MrakomorConfig) | undefined;
+    resolveComponent?: ((arg0: string) => ComponentConstructor | undefined) | undefined;
+    wrapBlockElement?: ((arg0: any) => any | undefined) | undefined;
+    registerEvents?: ((arg0: Mrakomor) => void) | undefined;
+    registerHandlers?: ((arg0: Mrakomor) => void) | undefined;
+    registerCommands?: ((arg0: Mrakomor) => void) | undefined;
+    registerListeners?: ((arg0: Mrakomor) => void) | undefined;
+    onKeyDown?: ((arg0: KeydownEvent) => void) | undefined;
+    onMount?: ((arg0: Mrakomor) => void) | undefined;
+    onUnmount?: ((arg0: Mrakomor) => void) | undefined;
+};
+export type PluginFactory = (context: PluginContext) => Plugin;
+/**
+ * Caret/selection snapshot that survives remount.
+ */
+export type SelectionState = {
+    start: number;
+    end: number;
+    element: Element | null;
+    selectableElement?: Node | null | undefined;
+};
+/**
+ * Non-collapsed selection that may span blocks.
+ */
+export type CrossBlockSelectionState = {
+    startBlock: Element;
+    endBlock: Element;
+    startOffset: number;
+    endOffset: number;
+};
+/**
+ * Copy/cut/paste selection in content-array indexes.
+ */
+export type ClipboardSelection = {
+    collapsed?: boolean | undefined;
+    startIndex: number;
+    endIndex: number;
+    startOffset: number;
+    endOffset: number;
+    /**
+     * start list item, or the only item
+     */
+    listItemIndex?: number | undefined;
+    /**
+     * end list item when the selection spans items
+     */
+    endListItemIndex?: number | undefined;
+};
+/**
+ * Result of delete/paste/merge on the content array.
+ */
+export type ContentMutation = {
+    content: BlockState[];
+    resultIndex: number;
+    cursor: number;
+    listItemIndex?: number | undefined;
+};
+/**
+ * Split of a text block at the caret.
+ */
+export type SplitBlockResult = {
+    originalLineState: RichTextState;
+    newLineState: RichTextState;
+};
+/**
+ * Lift one list item to a text block, splitting the list around it.
+ */
+export type UnwrapListResult = {
+    blocks: BlockState[];
+    paragraphIndex: number;
+};
+/**
+ * Tooltip button descriptor.
+ */
+export type TooltipAction = {
+    label: string | Function | object;
+    title?: string | object | Function | undefined;
+    group?: string | undefined;
+    active?: (() => boolean) | undefined;
+    onAction: (arg0: Mrakomor) => void;
+};
+/**
+ * Emitter event from `mrakomor.emit` (`@esmj/emitter`).
+ */
+export type EmitterEvent = {
+    name: string;
+    context: any;
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+    stopPropagation: () => void;
+    mrakomor?: Mrakomor | undefined;
+    /**
+     * payload of `CONTENT_CHANGE`
+     */
+    content?: BlockState<Record<string, any>, Record<string, any>>[] | undefined;
+    /**
+     * payload of `FOCUSOUT` / `FOCUSIN`
+     */
+    relatedTarget?: EventTarget | null | undefined;
+    /**
+     * payload of `CLICK` (viewport X, native `MouseEvent.clientX`)
+     */
+    clientX?: number | undefined;
+    /**
+     * payload of `CLICK` (viewport Y, native `MouseEvent.clientY`)
+     */
+    clientY?: number | undefined;
+};
+/**
+ * KEYDOWN payload bridged onto the editor emitter.
+ */
+export type KeydownEvent = EmitterEvent;
+/**
+ * INPUT / BEFORE_INPUT payload bridged onto the editor emitter.
+ */
+export type InputDomEvent = EmitterEvent;
+/**
+ * `entityRangeSchema()` options.
+ */
+export type EntityRangeSchemaOptions = {
+    /**
+     * default `entity.type` (entity classes)
+     */
+    type?: string | undefined;
+    /**
+     * schema for `entity.data` (default `s.any()`)
+     */
+    data?: import("@esmj/schema").SchemaType | undefined;
+    length?: number | undefined;
+    offset?: number | undefined;
+};
+/**
+ * `blockStateSchema()` field spec.
+ */
+export type BlockStateSchemaSpec = {
+    /**
+     * dotted NAMESPACE
+     */
+    component: string;
+    /**
+     * field schemas for `properties`
+     */
+    properties: {
+        [x: string]: import("@esmj/schema").SchemaType;
+    };
+    /**
+     * settings schema (default empty object)
+     */
+    settings?: import("@esmj/schema").SchemaType | undefined;
+};