superdoc 2.2.0 → 2.3.0

package/dist/document-api/src/inline-semantics/directives.d.ts

@@ -0,0 +1,95 @@
+import { CorePropertyId } from './property-ids.js';
+/** Tri-state directive representing a run's direct inline formatting state. */
+export type DirectState = 'on' | 'off' | 'clear';
+/** Where the effective value came from. */
+export type Provenance = 'direct-on' | 'direct-off' | 'style-cascade' | 'unresolved';
+/**
+ * Full inline property state for a single property on a single run.
+ * Computed internally; `provenance` is not surfaced in the public contract yet.
+ */
+export interface InlinePropertyState {
+    direct: DirectState;
+    effective: boolean;
+    provenance: Provenance;
+}
+/**
+ * Derives effective and provenance from direct state without style-engine cascade.
+ *
+ * Used when converter context is unavailable (headless mode, unit tests, non-DOCX).
+ * - `'on'`   → effective: true, provenance: 'direct-on'
+ * - `'off'`  → effective: false, provenance: 'direct-off'
+ * - `'clear'` → effective: false, provenance: 'unresolved'
+ */
+export declare function derivePropertyStateFromDirect(direct: DirectState): InlinePropertyState;
+/**
+ * Creates a full property state with style-engine-resolved effective value.
+ *
+ * Used when converter context is available and the style-engine cascade
+ * has resolved the effective visual state.
+ */
+export declare function derivePropertyStateWithCascade(direct: DirectState, cascadeEffective: boolean): InlinePropertyState;
+/**
+ * Determines the resulting direct state after applying a directive.
+ *
+ * The transition matrix is symmetric across all core-4 properties for the
+ * tri-state directive model. The actual PM mark operations differ per property
+ * (handled by the PM-binding layer), but the state transitions are uniform.
+ *
+ * | Current | Directive | Result |
+ * |---------|-----------|--------|
+ * | on      | on        | on (no-op) |
+ * | on      | off       | off |
+ * | on      | clear     | clear |
+ * | off     | on        | on |
+ * | off     | off       | off (no-op) |
+ * | off     | clear     | clear |
+ * | clear   | on        | on |
+ * | clear   | off       | off |
+ * | clear   | clear     | clear (no-op) |
+ */
+export declare function applyDirectiveTransition(current: DirectState, directive: DirectState): DirectState;
+/**
+ * Returns true if applying the directive to the current state would produce
+ * an actual document change (not a no-op).
+ */
+export declare function wouldDirectiveChange(current: DirectState, directive: DirectState): boolean;
+/** Paragraph context for effective resolution. */
+export interface ResolutionParagraphContext {
+    styleId?: string;
+    properties: Record<string, unknown>;
+}
+/** Run context for effective resolution. */
+export interface ResolutionRunContext {
+    styleId?: string;
+    directProperties: Record<string, unknown>;
+}
+/** Numbering context (null when run is not in a list). */
+export interface ResolutionNumberingContext {
+    numId: string;
+    ilvl: number;
+}
+/** Table context (null when run is not in a table). */
+export interface ResolutionTableContext {
+    tableStyleId?: string;
+    rowIndex: number;
+    cellIndex: number;
+    numRows: number;
+    numCells: number;
+}
+/** Full resolution input for computing effective inline states. */
+export interface EffectiveResolutionInput {
+    paragraph: ResolutionParagraphContext;
+    run: ResolutionRunContext;
+    numbering: ResolutionNumberingContext | null;
+    table: ResolutionTableContext | null;
+    defaults: {
+        docDefaults: Record<string, unknown>;
+        theme?: Record<string, unknown>;
+    };
+    revision: string;
+}
+/**
+ * Resolver function signature for computing effective inline state.
+ * Returns the effective boolean for a single property.
+ */
+export type EffectiveResolver = (property: CorePropertyId, input: EffectiveResolutionInput) => boolean;

package/dist/document-api/src/inline-semantics/error-types.d.ts

@@ -0,0 +1,68 @@
+import { CorePropertyId, CoreTogglePropertyId } from './property-ids.js';
+interface InvalidInlineTokenBase {
+    code: 'INVALID_INLINE_TOKEN';
+    /** The invalid value (`null` if attribute absent where value is required). */
+    token: string | null;
+    /** Attribute-level OOXML xpath (e.g., `.../w:u/@w:themeTint`). */
+    xpath: string;
+    /** Optional human-readable context. */
+    context?: string;
+}
+/** Toggle property variant (bold/italic/strike): only `w:val` can fail. */
+export interface InvalidInlineTokenToggle extends InvalidInlineTokenBase {
+    property: CoreTogglePropertyId;
+    attribute: 'val';
+}
+/** Underline variant: `w:val` plus rich attrs can each fail independently. */
+export interface InvalidInlineTokenUnderline extends InvalidInlineTokenBase {
+    property: 'underline';
+    attribute: 'val' | 'color' | 'themeColor' | 'themeTint' | 'themeShade';
+}
+/**
+ * Discriminated union for invalid inline token errors/diagnostics.
+ * Dual use: thrown at runtime, collected as diagnostic during import.
+ */
+export type InvalidInlineTokenError = InvalidInlineTokenToggle | InvalidInlineTokenUnderline;
+/**
+ * Type alias for import-site readability.
+ * `InlineTokenDiagnostic` IS `InvalidInlineTokenError`: one type, one schema, zero drift.
+ */
+export type InlineTokenDiagnostic = InvalidInlineTokenError;
+/** Required resolution input fields (§4.1 applicability matrix). */
+export declare const REQUIRED_RESOLUTION_FIELDS: readonly ["defaults", "paragraph", "run", "revision"];
+export type RequiredResolutionField = (typeof REQUIRED_RESOLUTION_FIELDS)[number];
+export interface StyleResolutionFailedError {
+    code: 'STYLE_RESOLUTION_FAILED';
+    property: CorePropertyId;
+    field: RequiredResolutionField;
+    /** PM document position of the failing run. */
+    runPosition: number;
+    /** Block reference identifier for debugging. */
+    blockRef: string;
+    /** Optional human-readable context. */
+    context?: string;
+}
+interface InvalidTargetBase {
+    code: 'INVALID_TARGET';
+    /** Optional human-readable context. */
+    context?: string;
+}
+export interface InvalidTargetOutOfRange extends InvalidTargetBase {
+    reason: 'out_of_range';
+    target: {
+        from: number;
+        to: number;
+    };
+}
+export interface InvalidTargetInvalidSelector extends InvalidTargetBase {
+    reason: 'invalid_selector';
+    target: {
+        selector: string;
+    };
+}
+/**
+ * Discriminated union for invalid mutation target errors.
+ * Collapsed ranges (from === to) are NOT an error: they are a silent no-op.
+ */
+export type InvalidTargetError = InvalidTargetOutOfRange | InvalidTargetInvalidSelector;
+export {};

package/dist/document-api/src/inline-semantics/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Inline semantics: shared semantic layer (PM-independent).
+ *
+ * This is the single source of truth for inline property definitions,
+ * token acceptance sets, strict token parsers, error types, and directive
+ * transition semantics.
+ *
+ * Consumed by: contract validation, SDK, CLI, docs, conformance tests,
+ * and document-engine adapter layers.
+ */
+export { CORE_PROPERTY_IDS, CORE_PROPERTY_ID_SET, CORE_TOGGLE_PROPERTY_IDS, CORE_TOGGLE_PROPERTY_ID_SET, } from './property-ids.js';
+export type { CorePropertyId, CoreTogglePropertyId } from './property-ids.js';
+export { ST_ON_OFF_VALUES, ST_ON_OFF_VALUE_SET, ST_ON_OFF_ON_VALUES, ST_ON_OFF_OFF_VALUES, ST_UNDERLINE_VALUES, ST_UNDERLINE_VALUE_SET, ST_THEME_COLOR_VALUES, ST_THEME_COLOR_VALUE_SET, } from './token-sets.js';
+export type { StOnOffValue, StUnderlineValue, StThemeColorValue } from './token-sets.js';
+export { parseStOnOff, parseStUnderline, parseUnderlineColor, parseUnderlineThemeColor, parseUnderlineThemeModifier, } from './token-parsers.js';
+export type { TokenParseOk, TokenParseError, TokenParseResult, StOnOffParsed, StUnderlineParsed, } from './token-parsers.js';
+export { REQUIRED_RESOLUTION_FIELDS } from './error-types.js';
+export type { InvalidInlineTokenToggle, InvalidInlineTokenUnderline, InvalidInlineTokenError, InlineTokenDiagnostic, StyleResolutionFailedError, InvalidTargetOutOfRange, InvalidTargetInvalidSelector, InvalidTargetError, RequiredResolutionField, } from './error-types.js';
+export { derivePropertyStateFromDirect, derivePropertyStateWithCascade, applyDirectiveTransition, wouldDirectiveChange, } from './directives.js';
+export type { DirectState, Provenance, InlinePropertyState, ResolutionParagraphContext, ResolutionRunContext, ResolutionNumberingContext, ResolutionTableContext, EffectiveResolutionInput, EffectiveResolver, } from './directives.js';

package/dist/document-api/src/inline-semantics/property-ids.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Canonical inline property identifiers: single source of truth.
+ *
+ * All layers (contract, error schemas, SDK, CLI, registry, tests) must use
+ * these constants. No synonyms (e.g., "strikethrough") in contract-facing surfaces.
+ */
+/**
+ * All supported core inline property IDs.
+ * Order: bold, italic, underline, strike (matches OOXML spec element ordering).
+ */
+export declare const CORE_PROPERTY_IDS: readonly ["bold", "italic", "underline", "strike"];
+/** A single core inline property ID. */
+export type CorePropertyId = (typeof CORE_PROPERTY_IDS)[number];
+/** Runtime set for O(1) property ID validation. */
+export declare const CORE_PROPERTY_ID_SET: ReadonlySet<string>;
+/**
+ * Pure-toggle property IDs (ON/OFF use identical attribute patterns).
+ * Underline is excluded because it is a composite property (toggle + rich attrs).
+ */
+export declare const CORE_TOGGLE_PROPERTY_IDS: readonly ["bold", "italic", "strike"];
+/** A single pure-toggle property ID. */
+export type CoreTogglePropertyId = (typeof CORE_TOGGLE_PROPERTY_IDS)[number];
+/** Runtime set for O(1) toggle property ID validation. */
+export declare const CORE_TOGGLE_PROPERTY_ID_SET: ReadonlySet<string>;

package/dist/document-api/src/inline-semantics/token-parsers.d.ts

@@ -0,0 +1,59 @@
+import { CoreTogglePropertyId } from './property-ids.js';
+import { InvalidInlineTokenError } from './error-types.js';
+import { DirectState } from './directives.js';
+export type TokenParseOk<T> = {
+    ok: true;
+    value: T;
+};
+export type TokenParseError = {
+    ok: false;
+    error: InvalidInlineTokenError;
+};
+export type TokenParseResult<T> = TokenParseOk<T> | TokenParseError;
+/**
+ * Parsed result for an ST_OnOff property.
+ * `direct` is the canonical tri-state directive; `canonical` is the
+ * normalized OOXML value for export (`null` = ON bare element, `'0'` = OFF).
+ */
+export interface StOnOffParsed {
+    direct: DirectState;
+}
+/**
+ * Parses a `w:val` attribute value for an ST_OnOff property.
+ *
+ * @param property - The property being parsed (bold/italic/strike).
+ * @param val - The `w:val` attribute value, or `null` for bare element (e.g., `<w:b/>`).
+ * @param xpath - Attribute-level xpath for error reporting.
+ */
+export declare function parseStOnOff(property: CoreTogglePropertyId, val: string | null, xpath: string): TokenParseResult<StOnOffParsed>;
+export interface StUnderlineParsed {
+    direct: DirectState;
+    /** Underline type for ON states; `'none'` for OFF; `undefined` for absent. */
+    underlineType?: string;
+}
+/**
+ * Parses a `w:val` attribute for ST_Underline.
+ *
+ * @param val - The `w:val` attribute value, or `null` for bare `<w:u/>`.
+ * @param xpath - Attribute-level xpath for error reporting.
+ */
+export declare function parseStUnderline(val: string | null, xpath: string): TokenParseResult<StUnderlineParsed>;
+/**
+ * Parses and normalizes a `w:color` attribute on `<w:u>`.
+ *
+ * Accepts: 6-digit hex (with or without `#`), `auto`.
+ * - Valid hex → lowercase 6-digit with `#` prefix.
+ * - `auto` → `undefined` (theme-resolved, not stored as direct).
+ * - Invalid → error.
+ */
+export declare function parseUnderlineColor(val: string | null, xpath: string): TokenParseResult<string | undefined>;
+/**
+ * Parses a `w:themeColor` attribute on `<w:u>`.
+ * Must be an exact match from ST_ThemeColor (case-sensitive).
+ */
+export declare function parseUnderlineThemeColor(val: string | null, xpath: string): TokenParseResult<string | undefined>;
+/**
+ * Parses a `w:themeTint` or `w:themeShade` attribute on `<w:u>`.
+ * Must be a 2-digit hex string (00–FF). Normalizes to uppercase.
+ */
+export declare function parseUnderlineThemeModifier(val: string | null, attribute: 'themeTint' | 'themeShade', xpath: string): TokenParseResult<string | undefined>;

package/dist/document-api/src/inline-semantics/token-sets.d.ts

@@ -0,0 +1,34 @@
+/**
+ * OOXML token acceptance sets: strict, case-sensitive, per-property.
+ *
+ * These are the exhaustive sets of accepted values for inline property tokens.
+ * Any value not in these sets is an invalid token and must produce a structured
+ * diagnostic (import) or error (runtime).
+ */
+/**
+ * Accepted `w:val` values for ST_OnOff properties (case-sensitive, per OOXML spec).
+ * Absent `w:val` (bare element like `<w:b/>`) normalizes to ON: handled by parsers, not here.
+ */
+export declare const ST_ON_OFF_VALUES: readonly ["true", "false", "1", "0", "on", "off"];
+export type StOnOffValue = (typeof ST_ON_OFF_VALUES)[number];
+/** Runtime set for O(1) ST_OnOff validation. */
+export declare const ST_ON_OFF_VALUE_SET: ReadonlySet<string>;
+/** ST_OnOff values that normalize to ON. */
+export declare const ST_ON_OFF_ON_VALUES: ReadonlySet<string>;
+/** ST_OnOff values that normalize to OFF. */
+export declare const ST_ON_OFF_OFF_VALUES: ReadonlySet<string>;
+/**
+ * Accepted `w:val` values for ST_Underline (exhaustive, case-sensitive).
+ * `'none'` maps to OFF; all others map to ON with the specified underline type.
+ */
+export declare const ST_UNDERLINE_VALUES: readonly ["single", "double", "thick", "dotted", "dottedHeavy", "dash", "dashedHeavy", "dashLong", "dashLongHeavy", "dotDash", "dashDotHeavy", "dotDotDash", "dashDotDotHeavy", "wave", "wavyHeavy", "wavyDouble", "words", "none"];
+export type StUnderlineValue = (typeof ST_UNDERLINE_VALUES)[number];
+/** Runtime set for O(1) ST_Underline validation. */
+export declare const ST_UNDERLINE_VALUE_SET: ReadonlySet<string>;
+/**
+ * Accepted values for ST_ThemeColor (exhaustive, case-sensitive, per ECMA-376 §17.18.97).
+ */
+export declare const ST_THEME_COLOR_VALUES: readonly ["dark1", "light1", "dark2", "light2", "accent1", "accent2", "accent3", "accent4", "accent5", "accent6", "hyperlink", "followedHyperlink", "background1", "text1", "background2", "text2", "none"];
+export type StThemeColorValue = (typeof ST_THEME_COLOR_VALUES)[number];
+/** Runtime set for O(1) ST_ThemeColor validation. */
+export declare const ST_THEME_COLOR_VALUE_SET: ReadonlySet<string>;

package/dist/document-api/src/insert/insert.d.ts

@@ -0,0 +1,65 @@
+import { MutationOptions, WriteAdapter } from '../write/write.js';
+import { SelectionTarget, TargetLocator, SDMutationReceipt } from '../types/index.js';
+import { SDInsertInput } from '../types/structural-input.js';
+import { StoryLocator } from '../types/story.types.js';
+import { BlockNodeAddress } from '../types/base.js';
+import { Placement } from '../types/placement.js';
+import { SelectionMutationAdapter } from '../selection-mutation.js';
+/** Content format for the text insert operation payload. */
+export type InsertContentType = 'text' | 'markdown' | 'html';
+type OptionalInsertLocator = TargetLocator | {
+    target?: undefined;
+    ref?: undefined;
+};
+/** Text-based input for the insert operation. */
+export type TextInsertInput = OptionalInsertLocator & {
+    /** Optional insertion target (SelectionTarget). When omitted, inserts at the end of the document. */
+    target?: SelectionTarget;
+    /** Optional mutation ref returned by a prior find/query. Mutually exclusive with target. */
+    ref?: string;
+    /** The content to insert. Interpreted according to {@link TextInsertInput.type}. */
+    value: string;
+    /** Content format. Defaults to `'text'` when omitted. */
+    type?: InsertContentType;
+    /** Target a specific document story (body, header, footer, footnote, endnote). */
+    in?: StoryLocator;
+};
+/**
+ * Type-safe input for markdown/html inserts with block-level positioning.
+ * Accepts BlockNodeAddress targets and placement (routed through the structural insert path).
+ * Standalone export: not part of the InsertInput union to avoid type narrowing issues in the runtime.
+ */
+export type RichContentInsertInput = {
+    target?: SelectionTarget | BlockNodeAddress;
+    ref?: string;
+    value: string;
+    type: 'markdown' | 'html';
+    placement?: Placement;
+    in?: StoryLocator;
+};
+/** @deprecated Use {@link TextInsertInput} instead. */
+export type LegacyInsertInput = TextInsertInput;
+/**
+ * Input payload for the `doc.insert` operation.
+ *
+ * Discrimination: presence of `content` (structural) vs `value` (text string).
+ * These are mutually exclusive: providing both is an error.
+ */
+export type InsertInput = TextInsertInput | SDInsertInput;
+/** Returns true when the input uses the structural SDFragment shape. */
+export declare function isStructuralInsertInput(input: InsertInput): input is SDInsertInput;
+/**
+ * Executes an insert operation, routing to the appropriate adapter path.
+ *
+ * - Text inserts with `target` or `ref` route through the SelectionMutationAdapter.
+ * - Structural inserts (SDFragment) and non-text content types route through WriteAdapter.
+ * - Text inserts without a locator append at the document end via WriteAdapter.
+ *
+ * @param selectionAdapter - Adapter for target/ref-based text mutations.
+ * @param writeAdapter - Adapter for structural and untargeted writes.
+ * @param input - Insert payload (text string or structural SDFragment).
+ * @param options - Optional mutation options (changeMode, dryRun, expectedRevision).
+ * @returns Receipt indicating success/failure and mutation metadata.
+ */
+export declare function executeInsert(selectionAdapter: SelectionMutationAdapter, writeAdapter: WriteAdapter, input: InsertInput, options?: MutationOptions): SDMutationReceipt;
+export {};

package/dist/document-api/src/invoke/invoke.d.ts

@@ -0,0 +1,17 @@
+import { OperationId } from '../contract/types.js';
+import { OperationRegistry } from '../contract/operation-registry.js';
+import { DocumentApi } from '../index.js';
+type TypedDispatchHandler<K extends OperationId> = OperationRegistry[K]['options'] extends never ? (input: OperationRegistry[K]['input']) => OperationRegistry[K]['output'] : (input: OperationRegistry[K]['input'], options?: OperationRegistry[K]['options']) => OperationRegistry[K]['output'];
+export type TypedDispatchTable = {
+    [K in OperationId]: TypedDispatchHandler<K>;
+};
+/**
+ * Builds a dispatch table that maps every OperationId to the corresponding
+ * direct method call on the given DocumentApi instance.
+ *
+ * Each entry delegates to the direct method: no parallel execution path.
+ * The return type is {@link TypedDispatchTable}, which validates at compile
+ * time that each handler conforms to the {@link OperationRegistry} contract.
+ */
+export declare function buildDispatchTable(api: DocumentApi): TypedDispatchTable;
+export {};

package/dist/document-api/src/lists/lists.d.ts

@@ -0,0 +1,100 @@
+import { MutationOptions } from '../write/write.js';
+import { ListInsertInput, ListsGetInput, ListsInsertResult, ListsListQuery, ListsListResult, ListsMutateItemResult, ListTargetInput, ListItemInfo, ListsCreateInput, ListsCreateResult, ListsAttachInput, ListsDetachInput, ListsDetachResult, ListsDeleteInput, ListsDeleteResult, ListsJoinInput, ListsJoinResult, ListsCanJoinInput, ListsCanJoinResult, ListsSeparateInput, ListsSeparateResult, ListsMergeInput, ListsMergeResult, ListsSplitInput, ListsSplitResult, ListsSetLevelInput, ListsSetValueInput, ListsContinuePreviousInput, ListsCanContinuePreviousInput, ListsCanContinuePreviousResult, ListsSetLevelRestartInput, ListsConvertToTextInput, ListsConvertToTextResult, ListsApplyTemplateInput, ListsApplyPresetInput, ListsCaptureTemplateInput, ListsCaptureTemplateResult, ListsSetLevelNumberingInput, ListsSetLevelBulletInput, ListsSetLevelPictureBulletInput, ListsSetLevelAlignmentInput, ListsSetLevelIndentsInput, ListsSetLevelTrailingCharacterInput, ListsSetLevelMarkerFontInput, ListsClearLevelOverridesInput, ListsSetTypeInput, ListsGetStyleInput, ListsGetStyleResult, ListsApplyStyleInput, ListsRestartAtInput, ListsSetLevelNumberStyleInput, ListsSetLevelTextInput, ListsSetLevelStartInput, ListsSetLevelLayoutInput, ListsGetStateInput, ListsGetStateResult, ListsApplyInput, ListsContinueV2Input, ListsRestartV2Input, ListsRemoveV2Input } from './lists.types.js';
+export type { ListInsertInput, ListsGetInput, ListsInsertResult, ListsListQuery, ListsListResult, ListsMutateItemResult, ListTargetInput, ListItemInfo, ListsCreateInput, ListsCreateResult, ListsAttachInput, ListsDetachInput, ListsDetachResult, ListsDeleteInput, ListsDeleteResult, ListsJoinInput, ListsJoinResult, ListsCanJoinInput, ListsCanJoinResult, ListsSeparateInput, ListsSeparateResult, ListsMergeInput, ListsMergeResult, ListsSplitInput, ListsSplitResult, ListsSetLevelInput, ListsSetValueInput, ListsContinuePreviousInput, ListsCanContinuePreviousInput, ListsCanContinuePreviousResult, ListsSetLevelRestartInput, ListsConvertToTextInput, ListsConvertToTextResult, ListsApplyTemplateInput, ListsApplyPresetInput, ListsCaptureTemplateInput, ListsCaptureTemplateResult, ListsSetLevelNumberingInput, ListsSetLevelBulletInput, ListsSetLevelPictureBulletInput, ListsSetLevelAlignmentInput, ListsSetLevelIndentsInput, ListsSetLevelTrailingCharacterInput, ListsSetLevelMarkerFontInput, ListsClearLevelOverridesInput, ListsSetTypeInput, ListsGetStyleInput, ListsGetStyleResult, ListsApplyStyleInput, ListsRestartAtInput, ListsSetLevelNumberStyleInput, ListsSetLevelTextInput, ListsSetLevelStartInput, ListsSetLevelLayoutInput, ListsBlockTarget, ListsGetStateInput, ListsGetStateResult, ListsApplyInput, ListsContinueV2Input, ListsRestartV2Input, ListsRemoveV2Input, } from './lists.types.js';
+export interface ListsAdapter {
+    list(query?: ListsListQuery): ListsListResult;
+    get(input: ListsGetInput): ListItemInfo;
+    insert(input: ListInsertInput, options?: MutationOptions): ListsInsertResult;
+    indent(input: ListTargetInput, options?: MutationOptions): ListsMutateItemResult;
+    outdent(input: ListTargetInput, options?: MutationOptions): ListsMutateItemResult;
+    create(input: ListsCreateInput, options?: MutationOptions): ListsCreateResult;
+    attach(input: ListsAttachInput, options?: MutationOptions): ListsMutateItemResult;
+    detach(input: ListsDetachInput, options?: MutationOptions): ListsDetachResult;
+    delete(input: ListsDeleteInput, options?: MutationOptions): ListsDeleteResult;
+    join(input: ListsJoinInput, options?: MutationOptions): ListsJoinResult;
+    canJoin(input: ListsCanJoinInput): ListsCanJoinResult;
+    separate(input: ListsSeparateInput, options?: MutationOptions): ListsSeparateResult;
+    merge(input: ListsMergeInput, options?: MutationOptions): ListsMergeResult;
+    split(input: ListsSplitInput, options?: MutationOptions): ListsSplitResult;
+    setLevel(input: ListsSetLevelInput, options?: MutationOptions): ListsMutateItemResult;
+    setValue(input: ListsSetValueInput, options?: MutationOptions): ListsMutateItemResult;
+    continuePrevious(input: ListsContinuePreviousInput, options?: MutationOptions): ListsMutateItemResult;
+    canContinuePrevious(input: ListsCanContinuePreviousInput): ListsCanContinuePreviousResult;
+    setLevelRestart(input: ListsSetLevelRestartInput, options?: MutationOptions): ListsMutateItemResult;
+    convertToText(input: ListsConvertToTextInput, options?: MutationOptions): ListsConvertToTextResult;
+    applyTemplate(input: ListsApplyTemplateInput, options?: MutationOptions): ListsMutateItemResult;
+    applyPreset(input: ListsApplyPresetInput, options?: MutationOptions): ListsMutateItemResult;
+    captureTemplate(input: ListsCaptureTemplateInput): ListsCaptureTemplateResult;
+    setLevelNumbering(input: ListsSetLevelNumberingInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelBullet(input: ListsSetLevelBulletInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelPictureBullet(input: ListsSetLevelPictureBulletInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelAlignment(input: ListsSetLevelAlignmentInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelIndents(input: ListsSetLevelIndentsInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelTrailingCharacter(input: ListsSetLevelTrailingCharacterInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelMarkerFont(input: ListsSetLevelMarkerFontInput, options?: MutationOptions): ListsMutateItemResult;
+    clearLevelOverrides(input: ListsClearLevelOverridesInput, options?: MutationOptions): ListsMutateItemResult;
+    setType(input: ListsSetTypeInput, options?: MutationOptions): ListsMutateItemResult;
+    getStyle(input: ListsGetStyleInput): ListsGetStyleResult;
+    applyStyle(input: ListsApplyStyleInput, options?: MutationOptions): ListsMutateItemResult;
+    restartAt(input: ListsRestartAtInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelNumberStyle(input: ListsSetLevelNumberStyleInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelText(input: ListsSetLevelTextInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelStart(input: ListsSetLevelStartInput, options?: MutationOptions): ListsMutateItemResult;
+    setLevelLayout(input: ListsSetLevelLayoutInput, options?: MutationOptions): ListsMutateItemResult;
+    getState?(input: ListsGetStateInput): ListsGetStateResult;
+    apply?(input: ListsApplyInput, options?: MutationOptions): ListsMutateItemResult;
+    continue?(input: ListsContinueV2Input, options?: MutationOptions): ListsMutateItemResult;
+    restart?(input: ListsRestartV2Input, options?: MutationOptions): ListsMutateItemResult;
+    remove?(input: ListsRemoveV2Input, options?: MutationOptions): ListsMutateItemResult;
+}
+export interface ListsApi extends ListsAdapter {
+    getState(input: ListsGetStateInput): ListsGetStateResult;
+    apply(input: ListsApplyInput, options?: MutationOptions): ListsMutateItemResult;
+    continue(input: ListsContinueV2Input, options?: MutationOptions): ListsMutateItemResult;
+    restart(input: ListsRestartV2Input, options?: MutationOptions): ListsMutateItemResult;
+    remove(input: ListsRemoveV2Input, options?: MutationOptions): ListsMutateItemResult;
+}
+export declare function executeListsList(adapter: ListsAdapter, query?: ListsListQuery): ListsListResult;
+export declare function executeListsGet(adapter: ListsAdapter, input: ListsGetInput): ListItemInfo;
+export declare function executeListsInsert(adapter: ListsAdapter, input: ListInsertInput, options?: MutationOptions): ListsInsertResult;
+export declare function executeListsIndent(adapter: ListsAdapter, input: ListTargetInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsOutdent(adapter: ListsAdapter, input: ListTargetInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsCreate(adapter: ListsAdapter, input: ListsCreateInput, options?: MutationOptions): ListsCreateResult;
+export declare function executeListsAttach(adapter: ListsAdapter, input: ListsAttachInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsDetach(adapter: ListsAdapter, input: ListsDetachInput, options?: MutationOptions): ListsDetachResult;
+export declare function executeListsDelete(adapter: ListsAdapter, input: ListsDeleteInput, options?: MutationOptions): ListsDeleteResult;
+export declare function executeListsJoin(adapter: ListsAdapter, input: ListsJoinInput, options?: MutationOptions): ListsJoinResult;
+export declare function executeListsCanJoin(adapter: ListsAdapter, input: ListsCanJoinInput): ListsCanJoinResult;
+export declare function executeListsSeparate(adapter: ListsAdapter, input: ListsSeparateInput, options?: MutationOptions): ListsSeparateResult;
+export declare function executeListsMerge(adapter: ListsAdapter, input: ListsMergeInput, options?: MutationOptions): ListsMergeResult;
+export declare function executeListsSplit(adapter: ListsAdapter, input: ListsSplitInput, options?: MutationOptions): ListsSplitResult;
+export declare function executeListsSetLevel(adapter: ListsAdapter, input: ListsSetLevelInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetValue(adapter: ListsAdapter, input: ListsSetValueInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsContinuePrevious(adapter: ListsAdapter, input: ListsContinuePreviousInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsCanContinuePrevious(adapter: ListsAdapter, input: ListsCanContinuePreviousInput): ListsCanContinuePreviousResult;
+export declare function executeListsSetLevelRestart(adapter: ListsAdapter, input: ListsSetLevelRestartInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsConvertToText(adapter: ListsAdapter, input: ListsConvertToTextInput, options?: MutationOptions): ListsConvertToTextResult;
+export declare function executeListsApplyTemplate(adapter: ListsAdapter, input: ListsApplyTemplateInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsApplyPreset(adapter: ListsAdapter, input: ListsApplyPresetInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsCaptureTemplate(adapter: ListsAdapter, input: ListsCaptureTemplateInput): ListsCaptureTemplateResult;
+export declare function executeListsSetLevelNumbering(adapter: ListsAdapter, input: ListsSetLevelNumberingInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelBullet(adapter: ListsAdapter, input: ListsSetLevelBulletInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelPictureBullet(adapter: ListsAdapter, input: ListsSetLevelPictureBulletInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelAlignment(adapter: ListsAdapter, input: ListsSetLevelAlignmentInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelIndents(adapter: ListsAdapter, input: ListsSetLevelIndentsInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelTrailingCharacter(adapter: ListsAdapter, input: ListsSetLevelTrailingCharacterInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelMarkerFont(adapter: ListsAdapter, input: ListsSetLevelMarkerFontInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsClearLevelOverrides(adapter: ListsAdapter, input: ListsClearLevelOverridesInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetType(adapter: ListsAdapter, input: ListsSetTypeInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsGetStyle(adapter: ListsAdapter, input: ListsGetStyleInput): ListsGetStyleResult;
+export declare function executeListsApplyStyle(adapter: ListsAdapter, input: ListsApplyStyleInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsRestartAt(adapter: ListsAdapter, input: ListsRestartAtInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelNumberStyle(adapter: ListsAdapter, input: ListsSetLevelNumberStyleInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelText(adapter: ListsAdapter, input: ListsSetLevelTextInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelStart(adapter: ListsAdapter, input: ListsSetLevelStartInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsSetLevelLayout(adapter: ListsAdapter, input: ListsSetLevelLayoutInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsGetState(adapter: ListsAdapter, input: ListsGetStateInput): ListsGetStateResult;
+export declare function executeListsApply(adapter: ListsAdapter, input: ListsApplyInput, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsContinueV2(adapter: ListsAdapter, input: ListsContinueV2Input, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsRestartV2(adapter: ListsAdapter, input: ListsRestartV2Input, options?: MutationOptions): ListsMutateItemResult;
+export declare function executeListsRemoveV2(adapter: ListsAdapter, input: ListsRemoveV2Input, options?: MutationOptions): ListsMutateItemResult;