@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

package/dist/prosemirror/autospacingBase.d.ts

@@ -0,0 +1,11 @@
+import { ParagraphAttrs } from "./schema/nodes.js";
+
+//#region src/prosemirror/autospacingBase.d.ts
+type AutospacingBase = NonNullable<ParagraphAttrs["_autospacingBase"]>;
+type AutospacingSide = "before" | "after";
+declare function normalizeAutospacingBaseValue(value: unknown): number | null;
+declare function setAutospacingBaseValue(base: AutospacingBase, side: AutospacingSide, value: unknown): void;
+declare function hasAutospacingBaseSide(base: ParagraphAttrs["_autospacingBase"] | null | undefined, side: AutospacingSide): boolean;
+declare function autospacingMatchesBase(base: ParagraphAttrs["_autospacingBase"] | null | undefined, side: AutospacingSide, currentValue: unknown): boolean;
+//#endregion
+export { autospacingMatchesBase, hasAutospacingBaseSide, normalizeAutospacingBaseValue, setAutospacingBaseValue };

package/dist/prosemirror/autospacingBase.js

@@ -0,0 +1,16 @@
+//#region src/prosemirror/autospacingBase.ts
+function normalizeAutospacingBaseValue(value) {
+	return typeof value === "number" ? value : null;
+}
+function setAutospacingBaseValue(base, side, value) {
+	base[side] = normalizeAutospacingBaseValue(value);
+}
+function hasAutospacingBaseSide(base, side) {
+	return base !== void 0 && base !== null && Object.hasOwn(base, side);
+}
+function autospacingMatchesBase(base, side, currentValue) {
+	if (!hasAutospacingBaseSide(base, side)) return false;
+	return normalizeAutospacingBaseValue(currentValue) === (base?.[side] ?? null);
+}
+//#endregion
+export { autospacingMatchesBase, hasAutospacingBaseSide, normalizeAutospacingBaseValue, setAutospacingBaseValue };

package/dist/prosemirror/commands/comments.d.ts

@@ -0,0 +1,93 @@
+import { Command, EditorState } from "prosemirror-state";
+
+//#region src/prosemirror/commands/comments.d.ts
+/**
+ * Add a comment mark to the current selection.
+ */
+declare function addCommentMark(commentId: number): Command;
+/**
+ * Remove a comment mark by ID from the entire document.
+ */
+declare function removeCommentMark(commentId: number): Command;
+type ParagraphBoundaryChange = {
+  from: number;
+  to: number;
+  type: "insertion" | "deletion";
+  author?: string;
+  date?: string;
+  revisionId?: number;
+};
+declare function findParagraphBoundaryChangeAtPosition(state: EditorState, pos: number): ParagraphBoundaryChange | null;
+/**
+ * Accept a tracked change at the given range.
+ * - Insertion: remove mark, keep text
+ * - Deletion: remove mark AND text
+ */
+declare function acceptChange(from: number, to: number): Command;
+/**
+ * Reject a tracked change at the given range.
+ * - Insertion: remove mark AND text
+ * - Deletion: remove mark, keep text
+ */
+declare function rejectChange(from: number, to: number): Command;
+/**
+ * Accept all tracked changes in the document.
+ */
+declare function acceptAllChanges(): Command;
+/**
+ * Reject all tracked changes in the document.
+ */
+declare function rejectAllChanges(): Command;
+/**
+ * Find the document range covered by all insertion/deletion marks
+ * carrying any of the given AI-edit `revisionIds`. Returns null when
+ * none of those marks are present (already accepted/rejected, or
+ * never existed). A replace operation typically passes two ids (one
+ * for its deletion side, one for its insertion side); inserts and
+ * standalone deletions pass a single id.
+ */
+declare function findAIEditRevisionRange(state: EditorState, revisionIds: number | readonly number[]): {
+  from: number;
+  to: number;
+} | null;
+/**
+ * Accept the tracked-change marks belonging to an AI-edit operation.
+ * Pass a single revisionId for inserts/standalone deletions, or the
+ * full id list for a replace (one id per side). Returns false when
+ * none of the ids match anything in the doc.
+ */
+declare function acceptAIEditRevision(revisionIds: number | readonly number[]): Command;
+/**
+ * Reject the tracked-change marks belonging to an AI-edit operation.
+ * See {@link acceptAIEditRevision} for the id semantics.
+ */
+declare function rejectAIEditRevision(revisionIds: number | readonly number[]): Command;
+type ChangeRange = {
+  from: number;
+  to: number;
+  type: "insertion" | "deletion";
+};
+/**
+ * Find the tracked change mark range at a given cursor position.
+ * If the cursor is inside a tracked change, returns the full extent
+ * of that mark (expanding to cover all adjacent nodes with the same
+ * revision ID). If from !== to (range selection), returns {from, to}.
+ */
+declare function findChangeAtPosition(state: EditorState, from: number, to: number): {
+  from: number;
+  to: number;
+};
+/**
+ * Find the next tracked change after the given position. Returns the full
+ * range of the change (including adjacent text nodes that share the same
+ * insertion/deletion mark instance), not just the first text node.
+ */
+declare function findNextChange(state: EditorState, startPos: number): ChangeRange | null;
+/**
+ * Find the previous tracked change before the given position. Returns the
+ * full range of the change (including adjacent text nodes that share the
+ * same insertion/deletion mark instance), not just the last text node.
+ */
+declare function findPreviousChange(state: EditorState, startPos: number): ChangeRange | null;
+//#endregion
+export { ParagraphBoundaryChange, acceptAIEditRevision, acceptAllChanges, acceptChange, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, rejectAIEditRevision, rejectAllChanges, rejectChange, removeCommentMark };

package/dist/prosemirror/commands/comments.js

@@ -0,0 +1,435 @@
+//#region src/prosemirror/commands/comments.ts
+/**
+* Add a comment mark to the current selection.
+*/
+function addCommentMark(commentId) {
+	return (state, dispatch) => {
+		const { from, to, empty } = state.selection;
+		if (empty) return false;
+		const commentType = state.schema.marks["comment"];
+		if (!commentType) return false;
+		if (dispatch) dispatch(state.tr.addMark(from, to, commentType.create({ commentId })));
+		return true;
+	};
+}
+/**
+* Remove a comment mark by ID from the entire document.
+*/
+function removeCommentMark(commentId) {
+	return (state, dispatch) => {
+		const commentType = state.schema.marks["comment"];
+		if (!commentType) return false;
+		if (dispatch) {
+			const tr = state.tr;
+			state.doc.descendants((node, pos) => {
+				if (node.isText) {
+					for (const mark of node.marks) if (mark.type === commentType && mark.attrs["commentId"] === commentId) tr.removeMark(pos, pos + node.nodeSize, mark);
+				}
+			});
+			if (tr.steps.length > 0) dispatch(tr);
+		}
+		return true;
+	};
+}
+/**
+* Resolve a tracked change: accept or reject.
+* - Accept: keep insertions (remove mark), delete deletions (remove text)
+* - Reject: keep deletions (remove mark), delete insertions (remove text)
+*
+* Pass `revisionId` to scope the operation to one specific
+* revision — otherwise overlapping marks for other revisions get
+* processed too, silently consuming pending work. Without an id
+* the operation matches every insertion/deletion mark in the
+* range (the bulk accept-all/reject-all path).
+*/
+function resolveChange(from, to, mode, revisionIds) {
+	return (state, dispatch) => {
+		const insertionType = state.schema.marks["insertion"];
+		const deletionType = state.schema.marks["deletion"];
+		if (!insertionType && !deletionType) return false;
+		const keepType = mode === "accept" ? insertionType : deletionType;
+		const removeType = mode === "accept" ? deletionType : insertionType;
+		const revisionSet = revisionIds === void 0 ? null : new Set(revisionIds);
+		const matchesRevision = (mark) => revisionSet === null || typeof mark.attrs["revisionId"] === "number" && revisionSet.has(mark.attrs["revisionId"]);
+		if (dispatch) {
+			const tr = state.tr;
+			const deleteRanges = [];
+			const pPrMarkOps = [];
+			state.doc.nodesBetween(from, to, (node, pos) => {
+				if (node.type.name === "paragraph") {
+					const op = collectPPrMarkOp(node, pos, from, to, mode, revisionSet);
+					if (op) pPrMarkOps.push(op);
+					const propertyChanges = node.attrs["_propertyChanges"];
+					if (Array.isArray(propertyChanges) && propertyChanges.length > 0 && rangeCoversParagraphBoundary(from, to, pos, node)) {
+						const matches = propertyChanges.filter((c) => revisionSet === null || c.info && revisionSet.has(c.info.id));
+						if (matches.length > 0) {
+							const remaining = propertyChanges.filter((c) => revisionSet !== null && (!c.info || !revisionSet.has(c.info.id)));
+							const nextAttrs = {
+								...node.attrs,
+								_propertyChanges: remaining.length > 0 ? remaining : null
+							};
+							if (mode === "reject") {
+								for (const change of matches.toReversed()) if (change.previousFormatting) for (const [key, val] of Object.entries(change.previousFormatting)) nextAttrs[key] = val;
+							}
+							tr.setNodeMarkup(pos, void 0, nextAttrs);
+						}
+					}
+					return true;
+				}
+				if (!node.isInline) return true;
+				const nodeEnd = pos + node.nodeSize;
+				const rangeFrom = Math.max(from, pos);
+				const rangeTo = Math.min(to, nodeEnd);
+				if (removeType && node.marks.some((m) => m.type === removeType && matchesRevision(m))) deleteRanges.push({
+					from: rangeFrom,
+					to: rangeTo
+				});
+				for (const mark of node.marks) if (keepType && mark.type === keepType && matchesRevision(mark)) tr.removeMark(rangeFrom, rangeTo, mark);
+				return true;
+			});
+			for (const range of deleteRanges.toReversed()) tr.delete(range.from, range.to);
+			pPrMarkOps.sort((a, b) => b.paragraphPos - a.paragraphPos);
+			for (const op of pPrMarkOps) {
+				const mappedPos = tr.mapping.map(op.paragraphPos);
+				const paragraph = tr.doc.nodeAt(mappedPos);
+				if (!paragraph || paragraph.type.name !== "paragraph") continue;
+				if (op.action === "clear") {
+					tr.setNodeAttribute(mappedPos, "pPrMark", null);
+					continue;
+				}
+				const joinPos = mappedPos + paragraph.nodeSize;
+				if (joinPos >= tr.doc.content.size) continue;
+				try {
+					tr.join(joinPos);
+					tr.setNodeAttribute(mappedPos, "pPrMark", null);
+				} catch {}
+			}
+			if (tr.steps.length > 0) dispatch(tr);
+		}
+		return true;
+	};
+}
+function collectPPrMarkOp(node, pos, from, to, mode, revisionSet) {
+	if (!rangeCoversParagraphBoundary(from, to, pos, node)) return null;
+	const pPrMark = node.attrs["pPrMark"];
+	if (!isPPrMarkAttr(pPrMark)) return null;
+	if (revisionSet !== null && !revisionSet.has(pPrMark.info.id)) return null;
+	return {
+		paragraphPos: pos,
+		action: pPrMark.kind === "ins" === (mode === "accept") ? "clear" : "join"
+	};
+}
+function rangeCoversParagraphBoundary(from, to, pos, node) {
+	const boundaryFrom = pos + node.nodeSize - 1;
+	const boundaryTo = pos + node.nodeSize;
+	return from <= boundaryFrom && to >= boundaryTo;
+}
+function isPPrMarkAttr(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const kind = value.kind;
+	const info = value.info;
+	if (kind !== "ins" && kind !== "del") return false;
+	if (typeof info !== "object" || info === null) return false;
+	return typeof info.id === "number";
+}
+function readRevisionInfo(info) {
+	const revision = {};
+	if (typeof info?.author === "string") revision.author = info.author;
+	if (typeof info?.date === "string") revision.date = info.date;
+	if (typeof info?.id === "number") revision.revisionId = info.id;
+	return revision;
+}
+function getListPropertyChangeType(attrs, change) {
+	const previousFormatting = change.previousFormatting;
+	if (previousFormatting == null || !Object.hasOwn(previousFormatting, "numPr")) return null;
+	const currentNumPr = attrs["numPr"];
+	const previousNumPr = previousFormatting["numPr"];
+	if (previousNumPr == null && currentNumPr != null) return "insertion";
+	if (previousNumPr != null && currentNumPr == null) return "deletion";
+	if (!areNumPrValuesEqual(previousNumPr, currentNumPr)) return currentNumPr == null ? "deletion" : "insertion";
+	return null;
+}
+function areNumPrValuesEqual(left, right) {
+	if (left == null || right == null) return left == right;
+	if (!isObjectRecord(left) || !isObjectRecord(right)) return Object.is(left, right);
+	return left["numId"] === right["numId"] && left["ilvl"] === right["ilvl"];
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function toParagraphBoundaryChange(node, pos, type, info) {
+	return {
+		from: pos + node.nodeSize - 1,
+		to: pos + node.nodeSize,
+		type,
+		...readRevisionInfo(info)
+	};
+}
+function findParagraphBoundaryChangeAtPosition(state, pos) {
+	const $pos = state.doc.resolve(pos);
+	const node = $pos.parent;
+	if (node.type.name !== "paragraph") return null;
+	const paragraphPos = $pos.before($pos.depth);
+	const pPrMark = node.attrs["pPrMark"];
+	if (isPPrMarkAttr(pPrMark)) return toParagraphBoundaryChange(node, paragraphPos, pPrMark.kind === "ins" ? "insertion" : "deletion", pPrMark.info);
+	const propertyChanges = node.attrs["_propertyChanges"];
+	if (!Array.isArray(propertyChanges)) return null;
+	for (const change of propertyChanges) {
+		const type = getListPropertyChangeType(node.attrs, change);
+		if (type) return toParagraphBoundaryChange(node, paragraphPos, type, change.info);
+	}
+	return null;
+}
+/**
+* Accept a tracked change at the given range.
+* - Insertion: remove mark, keep text
+* - Deletion: remove mark AND text
+*/
+function acceptChange(from, to) {
+	return resolveChange(from, to, "accept");
+}
+/**
+* Reject a tracked change at the given range.
+* - Insertion: remove mark AND text
+* - Deletion: remove mark, keep text
+*/
+function rejectChange(from, to) {
+	return resolveChange(from, to, "reject");
+}
+/**
+* Accept all tracked changes in the document.
+*/
+function acceptAllChanges() {
+	return (state, dispatch) => acceptChange(0, state.doc.content.size)(state, dispatch);
+}
+/**
+* Reject all tracked changes in the document.
+*/
+function rejectAllChanges() {
+	return (state, dispatch) => rejectChange(0, state.doc.content.size)(state, dispatch);
+}
+/**
+* Find the document range covered by all insertion/deletion marks
+* carrying any of the given AI-edit `revisionIds`. Returns null when
+* none of those marks are present (already accepted/rejected, or
+* never existed). A replace operation typically passes two ids (one
+* for its deletion side, one for its insertion side); inserts and
+* standalone deletions pass a single id.
+*/
+function findAIEditRevisionRange(state, revisionIds) {
+	const insertionType = state.schema.marks["insertion"];
+	const deletionType = state.schema.marks["deletion"];
+	if (!insertionType && !deletionType) return null;
+	const idSet = new Set(typeof revisionIds === "number" ? [revisionIds] : revisionIds);
+	const range = {
+		from: null,
+		to: null
+	};
+	state.doc.descendants((node, pos) => {
+		if (!node.isInline) return;
+		for (const mark of node.marks) if ((mark.type === insertionType || mark.type === deletionType) && typeof mark.attrs["revisionId"] === "number" && idSet.has(mark.attrs["revisionId"])) {
+			const start = pos;
+			const end = pos + node.nodeSize;
+			if (range.from === null || start < range.from) range.from = start;
+			if (range.to === null || end > range.to) range.to = end;
+			break;
+		}
+	});
+	if (range.from === null || range.to === null) return null;
+	return {
+		from: range.from,
+		to: range.to
+	};
+}
+/**
+* Accept the tracked-change marks belonging to an AI-edit operation.
+* Pass a single revisionId for inserts/standalone deletions, or the
+* full id list for a replace (one id per side). Returns false when
+* none of the ids match anything in the doc.
+*/
+function acceptAIEditRevision(revisionIds) {
+	return (state, dispatch) => {
+		const range = findAIEditRevisionRange(state, revisionIds);
+		if (!range) return false;
+		const ids = typeof revisionIds === "number" ? [revisionIds] : revisionIds;
+		return resolveChange(range.from, range.to, "accept", ids)(state, dispatch);
+	};
+}
+/**
+* Reject the tracked-change marks belonging to an AI-edit operation.
+* See {@link acceptAIEditRevision} for the id semantics.
+*/
+function rejectAIEditRevision(revisionIds) {
+	return (state, dispatch) => {
+		const range = findAIEditRevisionRange(state, revisionIds);
+		if (!range) return false;
+		const ids = typeof revisionIds === "number" ? [revisionIds] : revisionIds;
+		return resolveChange(range.from, range.to, "reject", ids)(state, dispatch);
+	};
+}
+/**
+* Find the tracked change mark range at a given cursor position.
+* If the cursor is inside a tracked change, returns the full extent
+* of that mark (expanding to cover all adjacent nodes with the same
+* revision ID). If from !== to (range selection), returns {from, to}.
+*/
+function findChangeAtPosition(state, from, to) {
+	if (from !== to) return {
+		from,
+		to
+	};
+	const insertionType = state.schema.marks["insertion"];
+	const deletionType = state.schema.marks["deletion"];
+	if (!insertionType && !deletionType) return {
+		from,
+		to
+	};
+	const $pos = state.doc.resolve(from);
+	const node = $pos.parent;
+	if (!node.isTextblock) return {
+		from,
+		to
+	};
+	let markStart = from;
+	let markEnd = from;
+	let foundMark;
+	node.forEach((child, offset) => {
+		const childStart = $pos.start() + offset;
+		const childEnd = childStart + child.nodeSize;
+		if (from >= childStart && from <= childEnd && child.isText) {
+			for (const mark of child.marks) if (mark.type === insertionType || mark.type === deletionType) {
+				foundMark = mark;
+				markStart = childStart;
+				markEnd = childEnd;
+			}
+		}
+	});
+	if (foundMark === void 0) {
+		const paragraphChange = findParagraphBoundaryChangeAtPosition(state, from);
+		return paragraphChange ? {
+			from: paragraphChange.from,
+			to: paragraphChange.to
+		} : {
+			from,
+			to
+		};
+	}
+	const sameMark = foundMark;
+	const children = [];
+	node.forEach((child, offset) => {
+		if (!child.isText) return;
+		const childStart = $pos.start() + offset;
+		children.push({
+			childStart,
+			childEnd: childStart + child.nodeSize,
+			marks: child.marks
+		});
+	});
+	let extended = true;
+	while (extended) {
+		extended = false;
+		for (const child of children) {
+			if (!child.marks.some((m) => m.eq(sameMark))) continue;
+			if (child.childEnd === markStart) {
+				markStart = child.childStart;
+				extended = true;
+			}
+			if (child.childStart === markEnd) {
+				markEnd = child.childEnd;
+				extended = true;
+			}
+		}
+	}
+	return {
+		from: markStart,
+		to: markEnd
+	};
+}
+/**
+* Walk outward from `[fromHint, toHint]` and return the full extent of the
+* tracked-change span carrying `mark` (matched via `Mark.eq`, so attrs like
+* `revisionId` distinguish adjacent changes). Used to keep the
+* navigation/scroll helpers honest when a tracked-change span is split
+* across multiple text nodes due to inline formatting (e.g., a bold word
+* inside an insertion).
+*/
+function expandTrackedChangeRange(state, mark, fromHint, toHint) {
+	const carriesSameInlineMark = (node) => node?.isInline === true && node.marks.some((m) => m.eq(mark));
+	let from = fromHint;
+	let to = toHint;
+	let $from = state.doc.resolve(from);
+	let nodeBefore = $from.nodeBefore;
+	while (carriesSameInlineMark(nodeBefore)) {
+		from -= nodeBefore.nodeSize;
+		$from = state.doc.resolve(from);
+		nodeBefore = $from.nodeBefore;
+	}
+	let $to = state.doc.resolve(to);
+	let nodeAfter = $to.nodeAfter;
+	while (carriesSameInlineMark(nodeAfter)) {
+		to += nodeAfter.nodeSize;
+		$to = state.doc.resolve(to);
+		nodeAfter = $to.nodeAfter;
+	}
+	return {
+		from,
+		to
+	};
+}
+/**
+* Find the next tracked change after the given position. Returns the full
+* range of the change (including adjacent text nodes that share the same
+* insertion/deletion mark instance), not just the first text node.
+*/
+function findNextChange(state, startPos) {
+	const insertionType = state.schema.marks["insertion"];
+	const deletionType = state.schema.marks["deletion"];
+	if (!insertionType && !deletionType) return null;
+	const result = { value: null };
+	state.doc.descendants((node, pos) => {
+		if (result.value) return false;
+		if (!node.isInline) return;
+		if (pos + node.nodeSize <= startPos) return;
+		for (const mark of node.marks) if (mark.type === insertionType || mark.type === deletionType) {
+			const expanded = expandTrackedChangeRange(state, mark, pos, pos + node.nodeSize);
+			result.value = {
+				from: expanded.from,
+				to: expanded.to,
+				type: mark.type === insertionType ? "insertion" : "deletion"
+			};
+			return false;
+		}
+	});
+	if (result.value === null && startPos > 0) return findNextChange(state, 0);
+	return result.value;
+}
+/**
+* Find the previous tracked change before the given position. Returns the
+* full range of the change (including adjacent text nodes that share the
+* same insertion/deletion mark instance), not just the last text node.
+*/
+function findPreviousChange(state, startPos) {
+	const insertionType = state.schema.marks["insertion"];
+	const deletionType = state.schema.marks["deletion"];
+	if (!insertionType && !deletionType) return null;
+	const result = { value: null };
+	let resultMark = null;
+	state.doc.descendants((node, pos) => {
+		if (!node.isInline) return;
+		if (pos >= startPos) return false;
+		if (result.value && resultMark && pos < result.value.to && node.marks.every((m) => m.type !== insertionType && m.type !== deletionType || m.eq(resultMark))) return;
+		for (const mark of node.marks) if (mark.type === insertionType || mark.type === deletionType) {
+			const expanded = expandTrackedChangeRange(state, mark, pos, pos + node.nodeSize);
+			result.value = {
+				from: expanded.from,
+				to: expanded.to,
+				type: mark.type === insertionType ? "insertion" : "deletion"
+			};
+			resultMark = mark;
+		}
+	});
+	if (result.value === null && startPos < state.doc.content.size) return findPreviousChange(state, state.doc.content.size);
+	return result.value;
+}
+//#endregion
+export { acceptAIEditRevision, acceptAllChanges, acceptChange, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, rejectAIEditRevision, rejectAllChanges, rejectChange, removeCommentMark };

package/dist/prosemirror/commands/contentControls.d.ts

@@ -0,0 +1,45 @@
+import { document_d_exports } from "../../types/document.js";
+import { ContentControlFilter } from "../../content-controls/findContentControls.js";
+import { SetContentControlContentInput, SetContentControlValueInput } from "../../content-controls/mutateContentControls.js";
+import { EditorState, Transaction } from "prosemirror-state";
+import { Node } from "prosemirror-model";
+
+//#region src/prosemirror/commands/contentControls.d.ts
+type ForceOption = {
+  force?: boolean;
+};
+type BlockSdtPMMatch = {
+  node: Node; /** Absolute PM position of the blockSdt's open tag. */
+  pos: number; /** Outer→inner index path through doc children. */
+  path: number[];
+};
+/** All blockSdt nodes in `doc` matching `filter`. Outer→inner traversal. */
+declare function findBlockSdtMatches(doc: Node, filter?: ContentControlFilter): BlockSdtPMMatch[];
+/** First match or null — convenience for editor-ref callers. */
+declare function findBlockSdtMatch(doc: Node, filter: ContentControlFilter): BlockSdtPMMatch | null;
+/**
+ * Project a `blockSdt` PM node's attrs onto the full modeled `SdtProperties`
+ * shape so the editor-ref `getContentControls` and lock-error messages
+ * surface every field downstream tooling expects (lock, placeholder,
+ * dateFormat, listItems, checked, etc.). Raw XML payloads are not exposed —
+ * those are for serializer replay, not for callers.
+ */
+declare function blockSdtAttrsToSdtProperties(node: Node): document_d_exports.SdtProperties;
+/**
+ * Replace a control's children with plain text (one paragraph) or
+ * pre-built PM blocks. Returns null when no match is present.
+ */
+declare function setContentControlContentTr(state: EditorState, filter: ContentControlFilter, input: SetContentControlContentInput, options?: ForceOption): Transaction | null;
+/**
+ * Internal helper for the block-content fill variant. Lives in this module
+ * so callers reuse the same lock-check and `replaceWith` shape; the
+ * conversion-aware `setContentControlContentBlocksTr` in
+ * `./contentControlsBlockFill.ts` wraps it.
+ */
+declare function replaceBlockSdtChildrenForFill(state: EditorState, filter: ContentControlFilter, children: readonly Node[], options?: ForceOption): Transaction | null;
+declare function setContentControlValueTr(state: EditorState, filter: ContentControlFilter, input: SetContentControlValueInput, options?: ForceOption): Transaction | null;
+declare function removeContentControlTr(state: EditorState, filter: ContentControlFilter, options?: ForceOption & {
+  keepContent?: boolean;
+}): Transaction | null;
+//#endregion
+export { BlockSdtPMMatch, blockSdtAttrsToSdtProperties, findBlockSdtMatch, findBlockSdtMatches, removeContentControlTr, replaceBlockSdtChildrenForFill, setContentControlContentTr, setContentControlValueTr };