@pygmalionjs/pygmalion 0.8.1 → 0.10.0

package/dist-lib/types/document/components.d.ts

@@ -0,0 +1,169 @@
+import type { DesignDocument, DocumentDiagnostic, DocumentDuplicateMetadataRemapper, DocumentNode, DocumentNodeKind, DocumentNodePatch, DocumentTransaction, DocumentValue } from './contracts.js';
+/**
+ * Component model on top of the document engine's component commands.
+ *
+ * Everything here is stored in `node.properties` so that the document contract is unchanged:
+ * - a component set is a container with `properties.componentSet === true` whose children are the
+ *   variant components; each variant carries `properties.variant`, a map of axis name to value, and its
+ *   layer name is the Figma-style `Axis=Value, Axis=Value` string;
+ * - a main component may declare `properties.componentProperties` (text, boolean and instance-swap
+ *   properties), each bound to layer addresses inside the definition; an instance's property value is
+ *   the override on those layers, so the document never stores a second copy of the value;
+ * - a nested instance inside a definition may set `properties.exposeInstanceProperties === true` so
+ *   that its definition's properties appear on every outer instance;
+ * - `properties.hidden === true` hides a layer; boolean properties toggle it.
+ *
+ * Override addresses are the definition node id (`layer`) or a slash-joined path through nested
+ * instances (`nestedInstance/layer`). Exact canonical IDs take precedence over nested paths.
+ * An address shadowed by an exact canonical ID is not exposed as an editable nested target.
+ */
+export declare const COMPONENT_SET_KEY = "componentSet";
+export declare const VARIANT_KEY = "variant";
+export declare const COMPONENT_PROPERTIES_KEY = "componentProperties";
+export declare const EXPOSE_PROPERTIES_KEY = "exposeInstanceProperties";
+export declare const HIDDEN_KEY = "hidden";
+export declare const COMPONENT_DESCRIPTION_KEY = "componentDescription";
+export declare const COMPONENT_DOCUMENTATION_KEY = "componentDocumentationLink";
+export declare const OVERRIDE_ADDRESS_SEPARATOR = "/";
+export declare const VARIANT_NAME_LIMIT = 64;
+export type ComponentVariantValues = Record<string, string>;
+export interface ComponentVariantAxis {
+    name: string;
+    values: string[];
+}
+export interface ComponentVariantSet {
+    setId: string;
+    name: string;
+    variantIds: string[];
+    axes: ComponentVariantAxis[];
+    diagnostics: DocumentDiagnostic[];
+}
+export type ComponentPropertyType = 'text' | 'boolean' | 'instanceSwap';
+export interface ComponentPropertyDefinition {
+    id: string;
+    name: string;
+    type: ComponentPropertyType;
+    /** Override addresses inside the definition that the property writes. */
+    targets: string[];
+    /** Instance-swap properties may list component ids to offer first. */
+    preferredValues?: string[];
+}
+export type InstanceOverrideField = 'name' | 'width' | 'height' | 'transform' | 'layout' | 'constraints' | 'definitionId' | `properties.${string}`;
+export interface InstanceOverride {
+    /** Override address, or the instance's own definition id for size and direct properties. */
+    address: string;
+    layerName: string;
+    field: InstanceOverrideField;
+    value: DocumentValue | undefined;
+    /** A property written on the instance node itself rather than through `overrides`. */
+    direct: boolean;
+}
+export interface InstanceLayer {
+    address: string;
+    nodeId: string;
+    name: string;
+    kind: DocumentNodeKind;
+    depth: number;
+    /** Nested instance addresses crossed to reach the layer; empty for the definition's own layers. */
+    through: string[];
+    resolved: DocumentNode;
+    definition: DocumentNode;
+    overridden: boolean;
+}
+export interface InstanceProperty {
+    id: string;
+    definition: ComponentPropertyDefinition;
+    /** Address prefix of the nested instance that exposes the property; empty for the definition's own. */
+    prefix: string;
+    targets: string[];
+    value: DocumentValue;
+    overridden: boolean;
+    mixed: boolean;
+}
+export interface OverrideAddressEntry {
+    address: string;
+    nodeId: string;
+    name: string;
+    kind: DocumentNodeKind;
+    parentAddress: string | null;
+}
+export interface ComponentSwapPlan {
+    status: 'ready' | 'unchanged' | 'blocked';
+    instanceId: string;
+    definitionId: string;
+    /** Explicit definition-relative mapping handed to `swapInstance`; names are matched here, never in the engine. */
+    overrideTargets: Record<string, string>;
+    /** Override addresses with no compatible target in the new definition; dropped only on explicit request. */
+    unmatched: string[];
+    diagnostics: DocumentDiagnostic[];
+}
+export declare const componentPropertyField: Readonly<Record<ComponentPropertyType, InstanceOverrideField>>;
+export declare function overrideAddressSegments(address: string): string[];
+export declare function joinOverrideAddress(...segments: readonly string[]): string;
+/**
+ * Every address an instance of `definitionId` can override: the definition's descendants and, through
+ * each nested instance, its definition's descendants prefixed with the nested instance's address.
+ */
+export declare function definitionOverrideAddresses(document: DesignDocument, definitionId: string, options?: {
+    nested?: boolean;
+}): OverrideAddressEntry[];
+export declare function isComponentSet(node: DocumentNode | undefined | null): boolean;
+export declare function isVariantValues(value: unknown): value is ComponentVariantValues;
+export declare function variantValuesOf(node: DocumentNode | undefined | null): ComponentVariantValues | null;
+/** `Size=Large, State=Hover` becomes `{ Size: 'Large', State: 'Hover' }`; any other name is not a variant name. */
+export declare function parseVariantName(name: string): ComponentVariantValues | null;
+export declare function formatVariantName(values: ComponentVariantValues): string;
+export declare function componentSetOf(document: DesignDocument, componentId: string): DocumentNode | null;
+export declare function describeComponentVariantSet(document: DesignDocument, setId: string): ComponentVariantSet;
+export declare function validateComponentSet(document: DesignDocument, setId: string): DocumentDiagnostic[];
+export declare function findVariant(document: DesignDocument, set: ComponentVariantSet, values: ComponentVariantValues): string | null;
+/** The variant reached by changing one axis of an instance's current variant; other axes keep their values. */
+export declare function variantSwitchTarget(document: DesignDocument, instanceId: string, axis: string, value: string): string | null;
+/** One container becomes the main component in place; any other selection is wrapped first, as in Figma. */
+export declare function createComponentFromLayers(tx: DocumentTransaction, document: DesignDocument, nodeIds: readonly string[], allocateId: (sourceNodeId: string) => string, name?: string): string;
+/** Wraps sibling components in a component set; names in `Axis=Value` form keep their axes, others become `Property 1`. */
+export declare function combineAsVariants(tx: DocumentTransaction, document: DesignDocument, componentIds: readonly string[], setId: string, name?: string): void;
+/** Duplicates a variant into its set below the existing variants and names it by its values. */
+export declare function addVariant(tx: DocumentTransaction, document: DesignDocument, setId: string, sourceVariantId: string, allocateId: (sourceNodeId: string) => string, values: ComponentVariantValues, options?: {
+    remapMetadata?: DocumentDuplicateMetadataRemapper;
+}): string;
+export declare function setVariantValues(tx: DocumentTransaction, document: DesignDocument, variantId: string, values: ComponentVariantValues): void;
+export declare function addVariantAxis(tx: DocumentTransaction, document: DesignDocument, setId: string, axis: string, defaultValue: string): void;
+export declare function renameVariantAxis(tx: DocumentTransaction, document: DesignDocument, setId: string, from: string, to: string): void;
+export declare function removeVariantAxis(tx: DocumentTransaction, document: DesignDocument, setId: string, axis: string): void;
+export declare function renameVariantValue(tx: DocumentTransaction, document: DesignDocument, setId: string, axis: string, from: string, to: string): void;
+/** Matches overrides to the new definition by address, then by unique layer name and kind; the engine receives the explicit result. */
+export declare function planInstanceSwap(document: DesignDocument, instanceId: string, definitionId: string): ComponentSwapPlan;
+export declare function applyInstanceSwap(tx: DocumentTransaction, plan: ComponentSwapPlan, options?: {
+    discardUnmatched?: boolean;
+}): void;
+export declare function planVariantSwitch(document: DesignDocument, instanceId: string, axis: string, value: string): ComponentSwapPlan;
+export declare function instanceLayers(document: DesignDocument, instanceId: string, options?: {
+    nested?: boolean;
+}): InstanceLayer[];
+export declare function listInstanceOverrides(document: DesignDocument, instanceId: string): InstanceOverride[];
+export declare function setInstanceOverride(tx: DocumentTransaction, instanceId: string, address: string, patch: DocumentNodePatch): void;
+/** Resets one layer, or one field of one layer; a direct instance property is removed from the instance node. */
+export declare function resetInstanceOverride(tx: DocumentTransaction, document: DesignDocument, instanceId: string, address: string, field?: InstanceOverrideField, direct?: boolean): void;
+export declare function resetInstanceSize(tx: DocumentTransaction, document: DesignDocument, instanceId: string): void;
+export declare function resetAllInstanceOverrides(tx: DocumentTransaction, instanceId: string, preserveProperties?: readonly string[]): void;
+/** Writes an instance's overrides into the shared definition and clears them; nested addresses become the nested instance's own overrides. */
+export declare function pushOverridesToMainComponent(tx: DocumentTransaction, document: DesignDocument, instanceId: string): void;
+export declare function isComponentPropertyDefinition(value: unknown): value is ComponentPropertyDefinition;
+export declare function componentPropertyDefinitions(node: DocumentNode | undefined | null): ComponentPropertyDefinition[];
+export declare function validateComponentProperties(document: DesignDocument, componentId: string): DocumentDiagnostic[];
+/** Adds a property, or replaces the one with the same id. */
+export declare function defineComponentProperty(tx: DocumentTransaction, document: DesignDocument, componentId: string, definition: ComponentPropertyDefinition): void;
+export declare function removeComponentProperty(tx: DocumentTransaction, document: DesignDocument, componentId: string, propertyId: string): void;
+/** The definition's own properties, then those exposed by nested instances, each read from the current overrides. */
+export declare function instanceProperties(document: DesignDocument, instanceId: string): InstanceProperty[];
+/** Writes the value as overrides on every target; a value equal to the definition's own removes the override instead. */
+export declare function setInstanceProperty(tx: DocumentTransaction, document: DesignDocument, instanceId: string, property: InstanceProperty, value: DocumentValue): void;
+export declare function resetInstanceProperty(tx: DocumentTransaction, document: DesignDocument, instanceId: string, property: InstanceProperty): void;
+/** Instances whose definition is `componentId`, in document order; nested instances inside other definitions included. */
+export declare function componentInstances(document: DesignDocument, componentId: string): string[];
+/** The main component a canonical layer belongs to (itself for a component), or null outside any definition. */
+export declare function mainComponentOf(document: DesignDocument, nodeId: string): string | null;
+export declare function validateDocumentComponents(document: DesignDocument): DocumentDiagnostic[];
+/** Component authoring metadata is draft-only until a source component codec is declared. */
+export declare function componentsSourceDiagnostics(after: DesignDocument, before: DesignDocument): DocumentDiagnostic[];

package/dist-lib/types/document/contracts.d.ts

@@ -0,0 +1,171 @@
+/** Serializable authoring state. Rendered trees are projections of this document. */
+export type DocumentValue = null | boolean | number | string | DocumentValue[] | {
+    [key: string]: DocumentValue;
+};
+export type DocumentMatrix = [number, number, number, number, number, number];
+export type DocumentNodeKind = 'root' | 'frame' | 'group' | 'component' | 'instance' | 'slot' | 'text' | 'vector';
+export interface DocumentLayout {
+    direction: 'horizontal' | 'vertical' | 'grid';
+    gap: number;
+    padding: number;
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    sizing?: 'fixed' | 'hug';
+    crossSizing?: 'fixed' | 'hug';
+    wrap?: boolean;
+    crossGap?: number;
+    distribute?: 'start' | 'center' | 'end' | 'space-between';
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    columns?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+}
+export type DocumentConstraint = 'start' | 'end' | 'center' | 'stretch' | 'scale';
+/** How a child follows its parent's resize; an omitted axis behaves as `start`. */
+export interface DocumentNodeConstraints {
+    horizontal?: DocumentConstraint;
+    vertical?: DocumentConstraint;
+}
+export interface DocumentNodePatch {
+    /** Nested instance target only; ordinary patch commands use swapInstance instead. */
+    definitionId?: string;
+    name?: string;
+    transform?: DocumentMatrix;
+    width?: number;
+    height?: number;
+    layout?: DocumentLayout | null;
+    constraints?: DocumentNodeConstraints;
+    properties?: Record<string, DocumentValue>;
+}
+export interface DocumentNode {
+    id: string;
+    kind: DocumentNodeKind;
+    name: string;
+    parentId: string | null;
+    children: string[];
+    /** Local affine transform, including translation relative to the parent. */
+    transform: DocumentMatrix;
+    width: number;
+    height: number;
+    layout?: DocumentLayout | null;
+    constraints?: DocumentNodeConstraints;
+    properties: Record<string, DocumentValue>;
+    /** Slots are explicit containers with optional child-kind restrictions. */
+    accepts?: DocumentNodeKind[];
+    /** An instance has no owned children; its render tree comes from its definition. */
+    definitionId?: string;
+    /** Definition-relative overrides. Instance sizes inherit unless overridden here. */
+    overrides?: Record<string, DocumentNodePatch>;
+}
+export interface DesignDocument {
+    schemaVersion: 1;
+    id: string;
+    sourceRevision: string;
+    rootId: string;
+    nodes: Record<string, DocumentNode>;
+    /** Domain adapters may store serializable sidecars, including bindings, here. */
+    metadata: Record<string, DocumentValue>;
+}
+export interface DocumentDiagnostic {
+    code: string;
+    message: string;
+    nodeId?: string;
+}
+export interface DocumentPreflightInput {
+    before: DesignDocument;
+    after: DesignDocument;
+    operations: readonly string[];
+}
+export interface DocumentEngineOptions {
+    preflight?: (input: DocumentPreflightInput) => readonly DocumentDiagnostic[];
+    historyLimit?: number;
+}
+export interface DocumentInstanceSwapOptions {
+    /** Explicit definition-relative addresses; names and child positions are never matched. */
+    overrideTargets?: Readonly<Record<string, string>>;
+    /** Unmapped or incompatible overrides reject the swap unless discarding is explicit. */
+    incompatibleOverrides?: 'reject' | 'discard';
+}
+export interface DocumentInstanceResetOptions {
+    /** Adapter-owned identity/source properties that are not presentation overrides. */
+    preserveProperties?: readonly string[];
+}
+export interface DocumentDuplicateMetadataInput {
+    /** State at the start of the duplicate command, including earlier transaction commands. */
+    before: DesignDocument;
+    /** Copied structure before sidecar remapping and final layout/preflight. */
+    after: DesignDocument;
+    nodeIds: Readonly<Record<string, string>>;
+}
+export type DocumentDuplicateMetadataRemapper = (input: DocumentDuplicateMetadataInput) => Record<string, DocumentValue>;
+export interface DocumentDuplicateOptions {
+    /** Defaults to the original parent, immediately after the selected subtree. */
+    parentId?: string;
+    index?: number;
+    preserveWorld?: boolean;
+    /** Pure callback, required for nonempty metadata. The adapter owns sidecar IDs and scope references. */
+    remapMetadata?: DocumentDuplicateMetadataRemapper;
+}
+export interface DocumentTransaction {
+    /** Restores a same-identity snapshot as one undoable transaction. */
+    replaceDocument(document: DesignDocument): void;
+    add(node: DocumentNode, parentId: string, index?: number): void;
+    patch(nodeId: string, patch: DocumentNodePatch): void;
+    move(nodeId: string, x: number, y: number): void;
+    resize(nodeId: string, width: number, height: number): void;
+    reparent(nodeId: string, parentId: string, index?: number, options?: {
+        preserveWorld?: boolean;
+    }): void;
+    moveOut(nodeId: string): void;
+    group(nodeIds: readonly string[], groupId: string, name?: string): void;
+    ungroup(groupId: string): void;
+    remove(nodeId: string): void;
+    defineComponent(nodeId: string): void;
+    createInstance(definitionId: string, instanceId: string, parentId: string, index?: number): void;
+    setOverride(instanceId: string, definitionNodeId: string, patch: DocumentNodePatch | null): void;
+    /** Keeps placement and explicit compatible overrides; host semantics use preflight. */
+    swapInstance(instanceId: string, definitionId: string, options?: DocumentInstanceSwapOptions): void;
+    /** Clears definition overrides and direct instance properties, retaining placement and name. */
+    resetInstanceOverrides(instanceId: string, options?: DocumentInstanceResetOptions): void;
+    detachInstance(instanceId: string, allocateId: (definitionNodeId: string) => string): void;
+    /** Copies owned children only; the ID allocator is pure and external definitions remain shared. */
+    duplicateSubtree(nodeId: string, allocateId: (sourceNodeId: string) => string, options?: DocumentDuplicateOptions): Readonly<Record<string, string>>;
+    setMetadata(key: string, value: DocumentValue | undefined): void;
+}
+export interface DocumentEngine {
+    readonly snapshot: DesignDocument;
+    readonly revision: number;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    transact(label: string, apply: (transaction: DocumentTransaction) => void): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    serialize(): string;
+    subscribe(listener: () => void): () => void;
+}
+export interface ResolvedDocumentNode {
+    /** Definition identity is retained so the UI can address explicit overrides. */
+    sourceNodeId: string;
+    /** Authored instance properties, excluding values inherited from its main component. */
+    instanceProperties?: Record<string, DocumentValue>;
+    instanceId?: string;
+    node: DocumentNode;
+    children: ResolvedDocumentNode[];
+}
+/** Optional presentation-time instance resolution; normal editing uses canonical definitions. */
+export interface DocumentResolveOptions {
+    resolveInstance?: (input: {
+        node: DocumentNode;
+        /** Outer-to-inner instance IDs. IDs remain opaque, including slashes. */
+        instancePath: readonly string[];
+        /** Effective overrides after outer and nested instance overrides have been merged. */
+        overrides: Readonly<Record<string, DocumentNodePatch>>;
+    }) => {
+        definitionId: string;
+        overrides: Record<string, DocumentNodePatch>;
+    } | undefined;
+}

package/dist-lib/types/document/engine.d.ts

@@ -0,0 +1,20 @@
+import type { DesignDocument, DocumentDiagnostic, DocumentEngine, DocumentEngineOptions, DocumentNode, DocumentNodePatch, ResolvedDocumentNode, DocumentResolveOptions } from './contracts.js';
+export declare class DocumentValidationError extends Error {
+    readonly diagnostics: readonly DocumentDiagnostic[];
+    constructor(diagnostics: readonly DocumentDiagnostic[]);
+}
+export declare function createDocumentNode(input: Pick<DocumentNode, 'id' | 'kind'> & Partial<DocumentNode>): DocumentNode;
+export declare function createDesignDocument(id: string, sourceRevision: string, rootId?: string): DesignDocument;
+/** Exact node IDs keep their meaning; slash paths cross only declared nested instances. */
+export declare function componentOverrideTarget(document: DesignDocument, definitionId: string, address: string, overrides?: Record<string, DocumentNodePatch>, definitions?: Set<string>): DocumentNode | undefined;
+/** Remap only canonical IDs reached by the address, never coincidental slash-separated text. */
+export declare function remapComponentOverrideAddress(document: DesignDocument, definitionId: string, address: string, nodeIds: Readonly<Record<string, string>>, overrides?: Record<string, DocumentNodePatch>): string;
+/** Resolves components without materializing a second mutable tree in the document. */
+export declare function resolveDocumentNode(document: DesignDocument, nodeId: string, options?: DocumentResolveOptions): ResolvedDocumentNode;
+/** Checks persisted trees before they become authoring state. */
+export declare function validateDesignDocument(document: DesignDocument): DocumentDiagnostic[];
+export declare function createDocumentEngine(input: DesignDocument, options?: DocumentEngineOptions): DocumentEngine;
+export declare function reopenDesignDocument(serialized: string, options?: DocumentEngineOptions): DocumentEngine;
+/** A detached serialized projection; consumers cannot mutate canonical state through it. */
+export declare function projectDesignDocument(document: DesignDocument): DesignDocument;
+export type { DesignDocument, DocumentEngine, DocumentNode, DocumentValue } from './contracts.js';

package/dist-lib/types/document/exportSettings.d.ts

@@ -0,0 +1,45 @@
+import type { DesignDocument, DocumentDiagnostic, DocumentNode, DocumentValue } from './contracts.js';
+export type ExportFormat = 'svg' | 'png' | 'jpg' | 'webp';
+export interface ExportSetting {
+    format: ExportFormat;
+    constraint: {
+        type: 'scale' | 'width' | 'height';
+        value: number;
+    };
+    suffix: string;
+    contentsOnly?: boolean;
+}
+export declare const DEFAULT_EXPORT_SETTING: ExportSetting;
+export declare function isExportSetting(value: unknown): value is ExportSetting;
+export declare function nodeExportSettings(node: Pick<DocumentNode, 'properties'>): ExportSetting[];
+export declare function exportSettingsProperties(properties: Record<string, DocumentValue>, settings: readonly ExportSetting[]): Record<string, DocumentValue>;
+export declare function exportDimensions(node: Pick<DocumentNode, 'width' | 'height'>, setting: ExportSetting): {
+    width: number;
+    height: number;
+    scale: number;
+};
+export interface SvgExportResult {
+    markup: string;
+    width: number;
+    height: number;
+    diagnostics: DocumentDiagnostic[];
+}
+/** Safe SVG export of document geometry. Any unsupported visual is reported and prevents export. */
+export declare function exportNodeSvg(document: DesignDocument, nodeId: string, setting?: ExportSetting): SvgExportResult;
+export interface RasterExportRequest {
+    document: DesignDocument;
+    nodeId: string;
+    format: 'png' | 'jpg' | 'webp';
+    width: number;
+    height: number;
+    scale: number;
+    contentsOnly: boolean;
+}
+export type RasterExportRenderer = (request: RasterExportRequest) => Promise<Uint8Array>;
+export interface DesignExportArtifact {
+    fileName: string;
+    mediaType: string;
+    bytes: Uint8Array;
+}
+/** Raster bytes come only from an explicit host renderer; no hidden capture or network access. */
+export declare function exportDesignNode(document: DesignDocument, nodeId: string, setting: ExportSetting, renderer?: RasterExportRenderer): Promise<DesignExportArtifact>;

package/dist-lib/types/document/geometry.d.ts

@@ -0,0 +1,11 @@
+import type { DesignDocument, DocumentMatrix } from './contracts.js';
+export declare function identityDocumentMatrix(): DocumentMatrix;
+export declare function multiplyDocumentMatrices(a: DocumentMatrix, b: DocumentMatrix): DocumentMatrix;
+export declare function invertDocumentMatrix(m: DocumentMatrix): DocumentMatrix;
+export declare function documentWorldTransform(document: DesignDocument, nodeId: string): DocumentMatrix;
+export declare function documentTransformedBounds(matrix: DocumentMatrix, width: number, height: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};

package/dist-lib/types/document/layout.d.ts

@@ -0,0 +1,53 @@
+import type { DocumentNode } from './contracts.js';
+/** Pure layout projection. Input nodes and intrinsic source leaves are never mutated. */
+export interface LayoutSpec {
+    direction: 'horizontal' | 'vertical' | 'grid';
+    gap: number;
+    padding: number;
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    sizing?: 'fixed' | 'hug';
+    crossSizing?: 'fixed' | 'hug';
+    wrap?: boolean;
+    crossGap?: number;
+    distribute?: 'start' | 'center' | 'end' | 'space-between';
+    paddingTop?: number;
+    paddingRight?: number;
+    paddingBottom?: number;
+    paddingLeft?: number;
+    columns?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+}
+export declare function layoutHugAxes(layout?: LayoutSpec | null): {
+    width: boolean;
+    height: boolean;
+};
+export interface LayoutChild {
+    position?: 'auto' | 'absolute';
+    horizontal?: 'fixed' | 'fill';
+    vertical?: 'fixed' | 'fill';
+    columnSpan?: number;
+}
+export interface LayoutPlacement {
+    nodeId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface LayoutResult {
+    width: number;
+    height: number;
+    children: LayoutPlacement[];
+}
+export declare function layoutProblem(value: unknown): string | null;
+export declare function layoutChildProblem(properties: DocumentNode['properties']): string | null;
+export declare function layoutChild(node: Pick<DocumentNode, 'properties'>): LayoutChild;
+export declare const isAbsoluteLayoutChild: (node: Pick<DocumentNode, "properties">) => boolean;
+export declare const participatesInLayout: (node: Pick<DocumentNode, "properties">) => boolean;
+export declare function applyLayout(node: Pick<DocumentNode, 'width' | 'height'> & {
+    layout?: LayoutSpec | null;
+    properties?: DocumentNode['properties'];
+}, children: readonly DocumentNode[]): LayoutResult;