WolfDocx Python API and CLI reference

discover_report_targets

List source-bound targets supported by the read-only report authoring surface.

discover_report_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

parse_report_request

Parse the strict JSON request for one atomic, report-wide authoring operation.

parse_report_request(value: Any) -> ReportRequest

load_report_request

load_report_request(path: str | Path) -> ReportRequest

report_target_structure_fingerprint

Return a text-masked bound fingerprint for a supported report target.

report_target_structure_fingerprint(source: str | Path, *, kind: str, target: Mapping[str, Any] | int, part: str = 'word/document.xml') -> str | None

author_report

Resolve every edit on the immutable source, verify once, then publish once.

author_report(request: ReportRequest) -> ReportAuthoringReport

wolfdocx quickstart

Create and run a deterministic package-only synthetic example.

• --output-dir (required)

wolfdocx init

Initialize a portable local project from baseline and approved DOCX files.

• baseline (required)
• approved (required)
• --project-dir default '.wolfdocx'
• --project-id
• --allow: Explicitly allow a reviewed change category.
• --allow-none default False: Create a policy that allows no semantic changes.
• --approve-observed default False: Explicitly authorize every category observed in this one approved pair.
• --require default []
• --active-content default 'preserve'
• --schema default 'disabled'
• --render default 'disabled'
• --content-assertions
• --approve-target-plan default False: Explicitly adopt a complete exact target plan inferred from the approved pair.
• --no-target-plan default False: Explicitly initialize without an exact target-change lane.
• --timeout default 120
• --dotnet-executable default 'dotnet'
• --validator-project default <absolute-path>
• --soffice-executable default 'soffice'
• --pdftoppm-executable default 'pdftoppm'

wolfdocx check

Stage and check one candidate with a local project policy.

• candidate (required)
• --project default '.wolfdocx/project.json'
• --output-dir: Portable evidence path relative to the project root.
• --open default False: Open the generated privacy-safe review HTML in the default browser.
• --visual-review default False: Include opt-in rendered document pages; requires an enabled render lane.
• --timeout default 120
• --dotnet-executable default 'dotnet'
• --validator-project default <absolute-path>
• --soffice-executable default 'soffice'
• --pdftoppm-executable default 'pdftoppm'

wolfdocx accept

Prepare a non-overwriting next-baseline proposal from passing evidence.

• --project default '.wolfdocx/project.json'
• --reason (required): Caller-supplied review reference; WolfDocx does not verify human approval.
• --evidence: Portable evidence path relative to the project root.

wolfdocx status

Inspect local project hashes and lifecycle state without modifying files.

• --project default '.wolfdocx/project.json'

wolfdocx activate

Activate one exact prepared proposal and archive the previous pair.

• --project default '.wolfdocx/project.json'
• --proposal (required): Exact candidate SHA-256 naming the prepared proposal.
• --reason (required): Caller-supplied activation reason; WolfDocx does not verify human identity or approval.
• --evidence: Portable evidence path relative to the project root.
• --confirm-activation default False: Explicitly authorize replacing the active policy pointer.

wolfdocx support

Export or verify a bounded privacy-safe local support bundle.

• wolfdocx support export: Export sanitized project, readiness, and issue-code diagnostics.
  • --project default '.wolfdocx/project.json'
  • --output (required)
  • --dotnet-executable default 'dotnet'
  • --validator-project default <absolute-path>
  • --soffice-executable default 'soffice'
  • --pdftoppm-executable default 'pdftoppm'
• wolfdocx support verify: Verify exact files, hashes, bounds, and sanitized JSON shapes.
  • bundle (required)

wolfdocx inspect

Inspect one DOCX package.

• document (required)
• --full default False: Include paragraph, table, and style records in JSON output.
• --statistics: Add document statistics: Word's main story, or all stories (headers, footers, notes, text boxes) the way LibreOffice counts them.
• --statistics-wolf: wolf executable for body-story line counts and pages; default: wolf on PATH.

wolfdocx diff

Compare a candidate DOCX to a baseline.

• baseline (required)
• candidate (required)
• --allow default []: Allow an intended change category.

wolfdocx compare

Publish an editable native redline of a bound baseline and revised pair.

• request (required): Path to a bound JSON comparison request.

wolfdocx gate

Run a versioned regression policy and write a durable evidence bundle.

• policy (required)
• --output-dir (required)
• --timeout default 120
• --dotnet-executable default 'dotnet'
• --validator-project default <absolute-path>
• --soffice-executable default 'soffice'
• --pdftoppm-executable default 'pdftoppm'
• --junit default False: Write junit.xml and pin it in ci-exports.json.
• --summary default False: Write summary.md and pin it in ci-exports.json.
• --review default False: Write a self-contained privacy-safe review.html artifact.
• --visual-review default False: Write an opt-in local visual-review bundle containing rendered document pages; requires the render lane.

wolfdocx evidence

Verify a transported or archived WolfDocx gate evidence bundle.

• wolfdocx evidence verify: Verify bounded files, hashes, manifest linkage, and summary consistency.
  • bundle (required)
  • --expect-manifest-sha256: Require the bundle trust manifest to match a SHA-256 obtained through a separate trusted channel.
  • --ssh-signature
  • --allowed-signers
  • --signer-identity
  • --revocation-file
  • --ssh-keygen-executable default 'ssh-keygen'
• wolfdocx evidence pack: Verify and package one evidence directory as a deterministic ZIP.
  • bundle (required)
  • --output (required)
• wolfdocx evidence sign: Sign one verified evidence manifest using an explicit SSH key.
  • bundle (required)
  • --key (required)
  • --output (required)
  • --ssh-keygen-executable default 'ssh-keygen'

wolfdocx doctor

Preflight external capabilities without opening DOCX inputs.

• --policy
• --suite
• --dotnet-executable default 'dotnet'
• --validator-project default <absolute-path>
• --soffice-executable default 'soffice'
• --pdftoppm-executable default 'pdftoppm'

wolfdocx contract

Export machine-readable schemas for versioned WolfDocx contracts.

• wolfdocx contract schema: Export the exact bundled JSON Schema for one contract.
  • kind (required)
  • --output (required)

wolfdocx policy

Draft and explicitly promote reviewed gate policies.

• wolfdocx policy draft: Observe one baseline/approved pair without creating an executable policy.
  • baseline (required)
  • approved (required)
  • --target-reference: Reviewed generated output used to infer mutable output targets while the primary baseline continues to govern broad intent.
  • --draft-id (required)
  • --output (required)
• wolfdocx policy schema: Export the bundled version 1 gate-policy JSON Schema.
  • --output (required)
• wolfdocx policy diff: Classify whether a reviewed gate policy became weaker.
  • before (required)
  • after (required)
• wolfdocx policy prepare-baseline: Prepare non-overwriting next-baseline files from passed evidence.
  • policy (required)
  • --evidence (required)
  • --output-policy (required)
  • --output-baseline (required)
  • --output-receipt (required)
  • --approval-reference
• wolfdocx policy promote: Create a gate policy from an explicitly reviewed draft.
  • draft (required)
  • --output (required)
  • --baseline-path (required)
  • --candidate-path (required)
  • --target-reference-path: Portable final-policy path for the reviewed target reference.
  • --allow
  • --allow-none default False
  • --require default []
  • --active-content (required)
  • --schema (required)
  • --render (required)
  • --content-assertions
  • --no-content-assertions default False
  • --use-draft-targets default False: Adopt the complete exact target proposal from the reviewed draft.
  • --target-changes: Use a reviewed JSON array of exact target selectors.
  • --no-target-changes default False: Explicitly promote without an exact target-change lane.

wolfdocx benchmark

Run labeled gate policies and measure regression decisions.

• manifest (required)
• --output-dir (required)
• --timeout default 120
• --dotnet-executable default 'dotnet'
• --validator-project default <absolute-path>
• --soffice-executable default 'soffice'
• --pdftoppm-executable default 'pdftoppm'

wolfdocx docagentbench

Score a frozen paired direct-versus-harness document-editing study.

• manifest (required)
• --output-dir (required)
• --timeout default 120
• --dotnet-executable default 'dotnet'
• --validator-project default <absolute-path>
• --soffice-executable default 'soffice'
• --pdftoppm-executable default 'pdftoppm'

wolfdocx suite

Run multiple named gate policies as one operational release decision.

• manifest (required)
• --output-dir (required)
• --timeout default 120
• --jobs default 1: Run up to COUNT independent policies concurrently (1-32; default: 1).
• --dotnet-executable default 'dotnet'
• --validator-project default <absolute-path>
• --soffice-executable default 'soffice'
• --pdftoppm-executable default 'pdftoppm'

wolfdocx render

Render a DOCX to PDF using an isolated LibreOffice headless profile.

• document (required)
• --output-dir (required)
• --timeout default 120
• --executable default 'soffice'
• --pdfinfo-executable default 'pdfinfo'
• --sandbox default 'required'

wolfdocx render-diff

Render two DOCX files with LibreOffice and compare rasterized pages.

• baseline (required)
• candidate (required)
• --output-dir (required)
• --expect default 'equivalent'
• --threshold default 0.0
• --dpi default 144
• --max-pages default 50
• --timeout default 120
• --soffice-executable default 'soffice'
• --pdftoppm-executable default 'pdftoppm'
• --sandbox default 'required'

wolfdocx render-native

Render a bound DOCX into SVG, PNG, TIFF, PDF, or fixed-page XPS with the first-party layout engine, using explicitly supplied local fonts.

• request (required): Path to a bound JSON native-render request.

wolfdocx corpus

Fetch or audit the licensed public DOCX corpus.

• wolfdocx corpus fetch: Download missing corpus files and verify their pinned hashes.
  • --manifest default 'corpus/manifest.json'
• wolfdocx corpus audit: Audit corpus provenance expectations and DOCX package health.
  • --manifest default 'corpus/manifest.json'
• wolfdocx corpus schema-audit: Validate every corpus document against its pinned Open XML SDK expectation.
  • --manifest default 'corpus/manifest.json'
  • --max-errors default 100
  • --timeout default 120
  • --dotnet-executable default 'dotnet'
  • --project default <absolute-path>

wolfdocx pilot

Audit a private anonymized template/approved/failed packet.

• wolfdocx pilot audit: Verify the packet privacy gate and reproduce its declared failure.
  • manifest (required)
• wolfdocx pilot scaffold: Hash three local DOCX files and create a blocked version 2 manifest for human privacy and policy review.
  • packet_dir (required)
  • --packet-id (required)
  • --template default 'template.docx'
  • --approved default 'approved.docx'
  • --failed default 'failed.docx'

wolfdocx word-evidence

Validate a detached report from a controlled Microsoft Word runner.

• wolfdocx word-evidence validate: Check runner, environment, policy, operation, artifact, and claim boundaries.
  • report (required)

wolfdocx security

Encrypt or decrypt one bound DOCX with the qualified optional encryption extra.

• wolfdocx security encrypt: Publish one Agile-encrypted container from a bound JSON security request.
  • request (required): Path to bound JSON security request.
• wolfdocx security decrypt: Publish the admitted DOCX plaintext of one bound Agile-encrypted container.
  • request (required): Path to bound JSON security request.
• wolfdocx security sanitize-inspect: Report the removal units of one source-bound DOCX package without writing.
  • request (required): Path to bound JSON sanitization inventory request.
• wolfdocx security sanitize: Remove the target identities one bound JSON sanitization request names.
  • request (required): Path to bound JSON sanitization request.
• wolfdocx security signature-inspect: Inspect every OPC XMLDSIG package signature without writing.
  • request (required): Path to bound JSON signature inspection request.
• wolfdocx security signature-sign: Publish one independently re-verified OPC XMLDSIG-signed DOCX.
  • request (required): Path to bound JSON signature signing request.

wolfdocx schema-validate

Validate a DOCX with the pinned Microsoft Open XML SDK.

• document (required)
• --file-format default 'microsoft365'
• --max-errors default 100
• --timeout default 120
• --dotnet-executable default 'dotnet'
• --project default <absolute-path>

wolfdocx batch-exit

Aggregate verified batch run receipt into deterministic process exit.

• receipt (required): Path to batch run receipt JSON file.
• --strict default False: Fail closed with typed error on unknown failure codes.

wolfdocx preflight

Run flagship preflight validation before batch execution.

• --manifest: Path to batch manifest JSON.
• --policy: Path or ID of gate policy.
• --environment: Target environment ID (e.g.
• --lane: Require specific evidence lane (e.g.
• --output: Write preflight receipt JSON to output file.
• --workspace: Temporary workspace directory for probe execution.
• --strict default False: Fail closed with typed rejection error if preflight is rejected.

wolfdocx evidence-lanes

Orchestrate and capture flagship evidence lanes.

• --document, --target-document: Path to target document DOCX.
• --environment: Target environment ID (e.g.
• --lane: Configure specific evidence lane.
• --output: Write flagship evidence receipt JSON to output file.
• --verify: Verify an existing flagship evidence receipt JSON file.
• --require-exact-head default False: Require exact git head verification during receipt verification.
• --strict default False: Fail closed if any configured lane fails or is blocked.

wolfdocx._comment_threads

• CommentReply (dataclass) One reply appended to an existing parent comment thread.
• CommentResolve (dataclass) One resolution status change on an existing comment thread.

wolfdocx.activation

• activate_project(*, project: str | Path = PosixPath('.wolfdocx/project.json'), proposal_id: str, reason: str, confirmed: bool, evidence: str | None = None) -> ProjectActivationReport

  Activate one exact prepared proposal while preserving the prior pair.

• ProjectActivationReport(passed: bool = ..., execution_error: bool = ..., project_id: str | None = ..., proposal_id: str | None = ..., evidence_dir: str | None = ..., source: dict[str, Any] = ..., activated: dict[str, Any] = ..., history: dict[str, Any] = ..., issues: list[str] = ...) (dataclass)

wolfdocx.archive

• pack_evidence_bundle(bundle: str | Path, *, output: str | Path) -> EvidencePackReport

• EvidenceArchiveError (exception)
• EvidencePackReport(passed: bool = ..., execution_error: bool = ..., output_name: str | None = ..., archive_sha256: str | None = ..., archive_size_bytes: int | None = ..., manifest_sha256: str | None = ..., bundle_kind: str | None = ..., file_count: int = ..., issues: list[str] = ...) (dataclass)

wolfdocx.assembly

• merge_docx(sources: Sequence[str | Path], output: str | Path, *, format_mode: ImportFormatMode = <ImportFormatMode.KEEP_SOURCE_FORMATTING: 'keep_source_formatting'>, format_options: ImportFormatOptions = ImportFormatOptions(smart_style_behavior=False, keep_source_numbering=True, ignore_header_footer=False, merge_pasted_lists=False, adjust_sentence_and_word_spacing=False, append_with_new_page=False, force_copy_styles=False, ignore_text_boxes=False, resolve_theme_colors=True), context: ProcessorContext | None = None) -> AssemblyReport

  Merge complete packages in order, using the first as the destination.

• ImportFormatMode (enum) Style collision policy; existing requests retain source formatting.
• ImportFormatOptions (dataclass) Paste policies shared by package assembly and session node import.
• SplitPart (dataclass) One published split output and the body content it carries.

wolfdocx.attribution

• LaneObservation (dataclass) Non-reconciling wall-clock and process-wide peak-RSS observation.
• LaneResourceDelta (dataclass) Exact counter delta for one package-analysis lane or ownership bucket.
• LaneResourceReceipt (dataclass) Immutable cumulative receipt for one named lane and package identity.
• PackageResourceReceipt (dataclass) Bounded receipt whose aggregate is exact for one AnalysisSession graph.

wolfdocx.baseline

• prepare_baseline_proposal(policy: str | Path, *, evidence: str | Path, output_policy: str, output_baseline: str, output_receipt: str, approval_reference: str | None = None) -> BaselineProposalReport

• BaselineProposalReport(passed: bool = ..., execution_error: bool = ..., gate_id: str | None = ..., evidence_manifest_sha256: str | None = ..., source_policy_sha256: str | None = ..., next_policy_sha256: str | None = ..., previous_baseline_sha256: str | None = ..., proposed_baseline_sha256: str | None = ..., output_policy: str | None = ..., output_baseline: str | None = ..., output_receipt: str | None = ..., issues: list[str] = ...) (dataclass)

wolfdocx.benchmark

• run_benchmark(manifest: str | Path, *, output_dir: str | Path, validator_project: str | Path = <absolute-path>, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', timeout_seconds: int = 120, gate_runner: GateRunner = <callable>) -> BenchmarkReport

• BenchmarkCaseResult (dataclass)
• BenchmarkIssue (dataclass)
• BenchmarkPolicyError (exception)
• BenchmarkReport(benchmark_id: str | None, manifest_path: str, manifest_sha256: str, output_dir: str, cases: list[BenchmarkCaseResult] = ..., issues: list[BenchmarkIssue] = ..., report_path: str | None = ...) (dataclass)

wolfdocx.bookmarks

• author_bookmark(request: BookmarkRequest) -> BookmarkReport

  Execute source-bound bookmark insertions and deletions atomically.

• discover_bookmark_targets(source: str | Path) -> dict[str, Any]

  List source-bound paragraph ranges and existing named bookmarks without writing.

• load_bookmark_request(path: str | Path) -> BookmarkRequest

  Load a bookmark authoring request from a UTF-8 JSON file.

• parse_bookmark_request(value: Any) -> BookmarkRequest

  Parse the strict JSON request for one atomic bookmark authoring operation.

• BookmarkDelete (dataclass) One removal of an existing bookmark, named by its name and fingerprint.
• BookmarkInsert (dataclass) One new bookmark anchored to an existing, source-bound paragraph range.
• BookmarkRename (dataclass) One rename of an existing bookmark, preserving its id, range, and updating references.
• BookmarkReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, bookmarks: list[dict[str, Any]], changed_targets: list[dict[str, Any]]) (dataclass)
• BookmarkRequest(source: Path, source_sha256: str, destination: Path, edits: tuple[BookmarkEdit, ...]) (dataclass)
• BookmarkTarget (dataclass) One source-bound native bookmark discovered in a package part.

wolfdocx.builder

• DocumentBuilder (class) Build or edit a valid document tree with an explicit insertion cursor.
• DocumentImage (dataclass) An inline or anchored picture run owned by one :class:`DocumentBuilder`.
• DocumentParagraph (dataclass) A paragraph node owned by one :class:`DocumentBuilder`.
• DocumentRun (dataclass) A run node owned by one :class:`DocumentBuilder`.
• DocumentSaveReport(content_type: str = ..., written_format: str = ..., destination: Path, sha256: str, paragraph_count: int, table_count: int, image_count: int) (dataclass) Receipt returned after a builder package is atomically published.
• DocumentTable (dataclass) A table node owned by one :class:`DocumentBuilder`.

wolfdocx.chart_formatting

• inspect_chart_formatting(source: str | Path) -> dict[str, Any]

  Every discoverable chart's formatting, in document chart order.

• AxisFormat (dataclass) Scale, crossing, ticks and labels of one axis.
• ChartFormatting (dataclass) Axis, legend and data-label formatting of one chart.
• DataLabelFormat (dataclass) What each data label shows, where it sits, its shape and how its value is formatted.
• LegendFormat (dataclass) Legend placement, overlay and its entry collection.

wolfdocx.charts

• author_chart_insert(request: ChartInsertRequest) -> ChartReport

  Create one standard inline chart part and its editable embedded workbook.

• author_chart_refresh(request: ChartRefreshRequest) -> ChartReport

  Refresh selected chart caches from explicitly hash-bound local XLSX values.

• author_chart_update(request: ChartUpdateRequest) -> ChartReport

  Replace one owned chart's cached series data and linked editable workbook.

• create_chart(source: str | Path, destination: str | Path, *, paragraph: int, chart_type: ChartType, categories: Sequence[ChartXValue | int], series: Sequence[ChartSeries], title: str | None = None, width_emu: int = 5486400, height_emu: int = 3657600, formatting: ChartFormatting | None = None) -> ChartReport

  Insert a standard chart; stock uses positional HLC/OHLC and radar marker style.

• discover_charts(source: str | Path) -> dict[str, Any]

  Return relationship-reachable inline chart targets without modifying a package.

• load_chart_refresh_request(path: str | Path) -> ChartRefreshRequest

  Load one UTF-8 JSON request; relative paths follow the caller's working directory.

• parse_chart_refresh_request(value: Any) -> ChartRefreshRequest

  Parse the strict offline-refresh JSON envelope without opening either input.

• update_chart(source: str | Path, destination: str | Path, *, chart: int, categories: Sequence[ChartXValue | int], series: Sequence[ChartSeries], title: str | None = None, formatting: ChartFormatting | None = None) -> ChartReport

  Replace chart data, updating only caches when the workbook is unusable.

• ChartInsertRequest(source: Path, source_sha256: str, destination: Path, paragraph: int, chart_type: ChartType, categories: tuple[ChartXValue, ...], series: tuple[ChartSeries, ...], title: str | None = ..., width_emu: int = ..., height_emu: int = ..., formatting: ChartFormatting | None = ...) (dataclass) One source-bound insertion of an inline standard 2D chart.
• ChartRefreshRequest(source: Path, source_sha256: str, destination: Path, chart: int, data_source: Path, data_source_sha256: str, worksheet: str, ranges: tuple[str, ...]) (dataclass) Explicit offline cache refresh; no workbook calculation or link fetching.
• ChartReport(status: Literal['published', 'refused'], code: str | None, source_sha256: str, destination_sha256: str | None, chart_part: str | None, workbook_part: str | None, chart_type: ChartType | None, series_count: int | None, point_count: int | None, non_target_parts_preserved: bool | None, workbook_updated: bool | None = ..., workbook_update_reason: str | None = ...) (dataclass) Bounded result for chart insertion or data update.
• ChartSeries (dataclass) One named series: its Y values in the order of the chart's X values.
• ChartUpdateRequest(source: Path, source_sha256: str, destination: Path, chart: int, categories: tuple[ChartXValue, ...], series: tuple[ChartSeries, ...], title: str | None = ..., clone_shared_part: bool = ..., formatting: ChartFormatting | None = ...) (dataclass) One source-bound chart-data update, selected by document chart ordinal.

wolfdocx.ci

• export_gate_ci_diagnostics(report: GateReport, *, output_dir: str | Path, junit: bool = False, markdown: bool = False, review: bool = False, visual_review: bool = False) -> dict[str, Any]

wolfdocx.comments

• author_comment(request: CommentRequest) -> CommentReport

  Resolve every edit on the immutable source, verify once, and publish once.

• discover_comment_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  List source-bound comment anchors and the paragraph targets a comment can bind to.

• load_comment_request(path: str | Path) -> CommentRequest
• parse_comment_request(value: Any) -> CommentRequest

  Parse the strict JSON request for one atomic comment authoring operation.

• CommentDelete (dataclass) One removal of an existing comment, named by its ID and its own fingerprint.
• CommentInsert (dataclass) One new comment anchored to an existing, source-bound paragraph range.
• CommentReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, comments: list[dict[str, Any]], changed_targets: list[dict[str, Any]]) (dataclass)
• CommentRequest(source: Path, source_sha256: str, destination: Path, edits: tuple[CommentEdit, ...]) (dataclass)
• CommentUpdate (dataclass) One rewrite of an existing comment, named by its ID and its own fingerprint.

wolfdocx.compare

• compare_documents(request: CompareRequest) -> CompareReport

  Publish an editable redline of ``revised`` against ``baseline``.

• load_compare_request(path: str | Path) -> CompareRequest
• parse_compare_request(value: Any) -> CompareRequest

• CompareReport(status: str, code: str | None, baseline_sha256: str, revised_sha256: str, output_sha256: str | None, revisions: list[dict[str, Any]], changes: list[dict[str, Any]]) (dataclass) The receipt for one comparison: both input digests plus every created revision.
• CompareRequest(baseline: Path, baseline_sha256: str, revised: Path, revised_sha256: str, output: Path, author: str, date: str, scope: tuple[str, ...] = ..., ignore_formatting: bool = ..., ignore_comments: bool = ..., ignore_fields: bool = ..., ignore_case_changes: bool = ..., detect_moves: bool = ...) (dataclass) One bound comparison: two checked inputs, one new output destination.

wolfdocx.content

• evaluate_content_assertions(assertions: list[ContentAssertion], candidate: InspectionReport) -> ContentAssertionReport
• parse_content_assertions(value: Any) -> list[ContentAssertion]

• ContentAssertion (dataclass)
• ContentAssertionReport(results: list[ContentAssertionResult] = ...) (dataclass)
• ContentAssertionResult (dataclass)
• ContentPolicyError (exception)
• ContentScope (dataclass)

wolfdocx.content_controls

• author_content_control(request: ContentControlRequest) -> ContentControlReport

  Insert or edit a source-bound control atomically, enforcing pre-edit locks.

• content_control_structure_fingerprint(source: str | Path, *, paragraph: int | None = None, sdt_id: int | None = None, tag: str | None = None, alias: str | None = None, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for a paragraph or content control.

• discover_content_control_targets(source: str | Path, *, part: str = 'word/document.xml', action: str | None = None) -> dict[str, Any]

  Inventory candidate direct body paragraphs and next unused SDT ID for insertion.

• load_content_control_request(path: str | Path) -> ContentControlRequest

  Load and strictly validate one JSON content control request from disk.

• parse_content_control_request(value: Any) -> ContentControlRequest

  Parse and strictly validate one JSON-compatible content control authoring request.

• ContentControlListItem (dataclass) An item in a drop-down list or combo-box content control.
• ContentControlReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., control: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public report for one content control authoring operation.
• ContentControlRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any] | ContentControlTarget, structure_fingerprint_sha256: str | None = ..., control: ContentControlSpec | Mapping[str, Any] | None = ..., action: str = ..., lock: str | None = ...) (dataclass) Strict request for inserting, flattening, or deleting a source-bound content control.
• ContentControlSpec (dataclass) Structured tag properties for block or inline insertion.
• ContentControlTarget (dataclass) One discovered candidate anchor or existing control for content control operations.

wolfdocx.contracts

• export_contract_schema(kind: str, output: str | Path) -> dict[str, object]

• ArtifactIdentity (dataclass)
• ContractArtifact (dataclass)
• ContractDiagnostic (dataclass)
• ContractIdentity (dataclass)
• ContractRequest(identity: ContractIdentity, input_artifacts: tuple[ContractArtifact, ...] = ...) (dataclass)
• ContractResult (dataclass)
• ContractTool (dataclass)
• ContractValidationError (exception) Raised when a contracted-core value or wire object is invalid.
• ToolIdentity (dataclass)

wolfdocx.convert

• convert(source: str | Path | BinaryIO, output: str | Path | BinaryIO | Sequence[BinaryIO], *, input_format: str | None = None, output_format: str | None = None, context: ProcessorContext | None = None, load_options: LoadOptions | None = None, save_options: SaveOptions | None = None) -> ConversionReport

  Execute a complete conversion, then publish paths or write caller streams.

• ConversionArtifact (dataclass) One output-relative file identity; pages are one-based when present.
• ConversionError (exception) A non-publishing conversion refusal with a stable, content-safe code.
• ConversionReport(source_format: str, output_format: str, source_sha256: str, package_sha256: str, output_sha256: str, output: str, files: tuple[ConversionArtifact, ...], omissions: tuple[Mapping[str, Any], ...] = ..., boundaries: tuple[str, ...] = ..., receipt: Mapping[str, Any] = ..., status: str = ..., code: str | None = ...) (dataclass) An immutable successful conversion and its ordered, content-safe loss receipt.
• ConversionRequest(source: str | Path | BinaryIO, output: str | Path | BinaryIO | Sequence[BinaryIO], input_format: str | None = ..., output_format: str | None = ..., context: ProcessorContext | None = ..., load_options: LoadOptions | None = ..., save_options: SaveOptions | None = ...) (dataclass) Reusable operation configuration; streams are consumed at their current position.

wolfdocx.corpus

• audit_corpus(path: str | Path = PosixPath('corpus/manifest.json')) -> CorpusReport
• audit_corpus_schema(path: str | Path = PosixPath('corpus/manifest.json'), *, project: str | Path = <absolute-path>, dotnet_executable: str = 'dotnet', max_errors: int = 100, timeout_seconds: int = 120, validator: Callable[..., SchemaValidationReport] = <callable>) -> CorpusReport
• fetch_corpus(path: str | Path = PosixPath('corpus/manifest.json')) -> CorpusReport

• CorpusReport(action: str, manifest: str, passed: bool = ..., issues: list[str] = ..., documents: list[dict[str, Any]] = ...) (dataclass)

wolfdocx.diff

• diff_reports(baseline: InspectionReport, candidate: InspectionReport, *, allowed_categories: Iterable[str] = ()) -> DiffReport

• DiffFinding (dataclass)
• DiffReport(baseline_sha256: str, candidate_sha256: str, allowed_categories: list[str], findings: list[DiffFinding], changed_parts: list[str], added_parts: list[str], removed_parts: list[str]) (dataclass)

wolfdocx.docagentbench

• run_docagentbench(manifest: str | Path, *, output_dir: str | Path, validator_project: str | Path = <absolute-path>, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', timeout_seconds: int = 120, gate_runner: GateRunner = <callable>) -> DocAgentBenchReport

wolfdocx.doctor

• run_doctor(policy: str | Path | None = None, *, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', validator_project: str | Path = <absolute-path>, resolver: ToolResolver = <callable>, version_probe: VersionProbe = <callable>) -> DoctorReport
• run_suite_doctor(manifest: str | Path, *, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', validator_project: str | Path = <absolute-path>, resolver: ToolResolver = <callable>, version_probe: VersionProbe = <callable>) -> SuiteDoctorReport

• Capability (dataclass)
• DoctorReport(policy_name: str | None, policy_sha256: str | None, capabilities: list[Capability] = ..., issues: list[str] = ..., execution_error: bool = ...) (dataclass)
• SuiteCapability (dataclass)
• SuiteDoctorCase (dataclass)
• SuiteDoctorReport(suite_id: str | None, manifest_name: str, manifest_sha256: str | None, cases: list[SuiteDoctorCase] = ..., capabilities: list[SuiteCapability] = ..., issues: list[str] = ..., execution_error: bool = ...) (dataclass)

wolfdocx.document

• Document (class) One DOCX package opened once and edited in memory until :meth:`save`.
• SessionSaveReport(content_type: str = ..., written_format: str = ..., status: str, code: str | None, source_sha256: str, destination: str, destination_sha256: str | None = ..., changed_parts: tuple[str, ...] = ..., added_parts: tuple[str, ...] = ..., removed_parts: tuple[str, ...] = ..., raw_copied_parts: int = ..., load_recovery: tuple[str, ...] = ..., edits: tuple[Mapping[str, Any], ...] = ...) (dataclass) Content-safe receipt for one :meth:`Document.save`.

wolfdocx.document_settings

• author_document_settings(request: DocumentSettingsRequest | Mapping[str, Any]) -> DocumentSettingsReport

  Publish only the requested settings, preserving untouched sibling bytes.

• discover_document_settings(source: str | Path) -> dict[str, Any]

  Read every native value, with source and exact settings-byte fingerprints.

• load_document_settings_request(path: str | Path) -> DocumentSettingsRequest
• parse_document_settings_request(value: Any) -> DocumentSettingsRequest

• DocumentSettingsReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., settings: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ..., omissions: tuple[str, ...] = ...) (dataclass)
• DocumentSettingsRequest(source: Path, destination: Path, source_sha256: str, structure_fingerprint_sha256: str, changes: Mapping[str, Any]) (dataclass) An immutable, source-bound settings patch.

wolfdocx.errors

• classify_failure(error: Exception) -> Failure

  Classify any exception into the public taxonomy without leaking content.

• failure_envelope(failure: Failure) -> dict[str, object]

  Build the public pathless, contentless JSON envelope for a failure.

• select_exit(*, decision_passed: bool, execution_failure: bool = False) -> ExitStatus

  The one centralized exit selection used by every CLI command.

• ErrorCategory (enum) Public failure categories; all map to :attr:`ExitStatus.EXECUTION_FAILURE`.
• ExitStatus (enum) Deterministic CLI exit codes.
• Failure (dataclass) Immutable machine-readable failure with a stable safe code.
• WolfDocxError (exception) Typed WolfDocx execution failure carrying a :class:`Failure`.

wolfdocx.evidence

• verify_evidence_bundle(bundle: str | Path, *, expected_manifest_sha256: str | None = None) -> EvidenceVerificationReport

  Verify the integrity and internal consistency of one gate evidence bundle.

• EvidenceIssue (dataclass)
• EvidenceVerificationReport(schema_version: int = ..., passed: bool = ..., execution_error: bool = ..., manifest_sha256: str | None = ..., bundle_kind: str | None = ..., files_checked: int = ..., bytes_checked: int = ..., visual_review_verified: bool = ..., expected_manifest_sha256_provided: bool = ..., expected_manifest_sha256_matched: bool | None = ..., authenticity_verified: bool = ..., transport_kind: str = ..., archive_sha256: str | None = ..., issues: list[EvidenceIssue] = ...) (dataclass)

wolfdocx.evidence_lanes

• canonicalize_lane_id(lane_id: str) -> str

  Resolve lane ID aliases to their canonical identifier.

• run_flagship_evidence_lanes(configuration: FlagshipLaneConfiguration | Mapping[str, Any] | None = None, *, workspace: Path | None = None, target_document: str | Path | None = None, environment: EnvironmentDescriptor | str | None = None, raise_on_rejection: bool = False) -> FlagshipEvidenceReceipt

  Orchestrate every configured evidence lane and emit an immutable FlagshipEvidenceReceipt.

• validate_flagship_evidence_schema(data: Mapping[str, Any]) -> None

  Validate data against flagship evidence receipt schema.

• verify_evidence_lane_completeness(receipt: FlagshipEvidenceReceipt, expected_lanes: Sequence[str] | None = None) -> bool

  The focused lane completeness gate: verify every configured lane emitted a typed result.

• verify_flagship_evidence_receipt(receipt_data: FlagshipEvidenceReceipt | Mapping[str, Any] | str | bytes, *, require_exact_head: bool = False, expected_source_identity: SourceIdentity | None = None, expected_lanes: Sequence[str] | None = None) -> FlagshipEvidenceReceipt

  Verify and parse a FlagshipEvidenceReceipt strictly against schema and hashes.

• EvidenceBlock (dataclass) Explicit, typed evidence block recording why a lane could not succeed.
• FlagshipEvidenceConfigurationError (exception) Configuration error in flagship evidence lanes.
• FlagshipEvidenceError (exception) Base error for flagship evidence lane operations.
• FlagshipEvidenceExecutionError (exception) Execution or invariant failure in evidence lanes.
• FlagshipEvidenceReceipt (dataclass) Immutable, cryptographically bound receipt of assembled flagship evidence.
• FlagshipEvidenceSchemaError (exception) Schema violation error for flagship evidence receipts.
• FlagshipEvidenceSummary (dataclass) Distinct summary of assembled evidence, preserving semantic vs renderer separation.
• FlagshipLaneConfiguration (dataclass) Declared, immutable configuration for evidence lane execution.
• FlagshipLaneResult (dataclass) Typed, labeled evidence result for one executed lane.

wolfdocx.field_delete

• author_field_delete(request: FieldDeleteRequest) -> FieldDeleteReport

  Delete an exact source-bound Word field or unlink it to static formatted content.

• discover_field_delete_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory supported field deletion/unlink targets in the document part.

• field_delete_structure_fingerprint(source: str | Path, *, paragraph: int, field: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for a field target.

• load_field_delete_request(path: str | Path) -> FieldDeleteRequest

  Load and parse one JSON-serialized FieldDeleteRequest.

• parse_field_delete_request(value: Any) -> FieldDeleteRequest

  Parse and strictly validate a field delete or unlink authoring request.

• FieldDeleteReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., action: str = ..., field: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a field delete or unlink authoring request.
• FieldDeleteRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, action: str = ...) (dataclass) One source-bound request to delete or unlink an exact field.
• FieldDeleteTarget (dataclass) One discovered candidate field target for deletion or unlinking.

wolfdocx.field_insert

• discover_field_insert_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inspect and inventory source-bound field insertion candidate paragraphs.

• field_insert_structure_fingerprint(source: str | Path, *, paragraph: int, part: str = 'word/document.xml') -> str | None

  Return the bounded paragraph structural fingerprint for request construction.

• insert_field(request: FieldInsertRequest) -> FieldInsertReport

  Execute one atomic, verified source-bound field insertion operation.

• load_field_insert_request(path: str | Path) -> FieldInsertRequest

  Load and strictly validate a field insertion request from JSON on disk.

• parse_field_insert_request(value: Any) -> FieldInsertRequest

  Parse and strictly validate one JSON-compatible field insertion request.

• FieldInsertReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, field: dict[str, Any] | None, target: dict[str, Any] | None, non_target_parts_preserved: bool | None) (dataclass) Report of one field insertion operation.
• FieldInsertRequest(source: Path, source_sha256: str, destination: Path, paragraph: int, start: int, end: int, expected_old_text: str, structure_fingerprint_sha256: str, instruction: str, part: str = ..., result_text: str | None = ..., form_field: FormFieldSpec | None = ...) (dataclass) Strict request for inserting one source-bound field sequence into a paragraph.
• FieldInsertTarget (dataclass) One discovered candidate paragraph target for field insertion.

wolfdocx.fields

• discover_field_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory every field of the main document part, plus the fields it does not own.

• discover_legacy_form_fields(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Discover legacy text, checkbox, and dropdown fields without modifying a package.

• load_field_refresh_request(path: str | Path) -> FieldRefreshRequest
• load_legacy_form_populate_request(path: str | Path) -> LegacyFormPopulateRequest

  Load and validate one legacy form population request from JSON.

• parse_field_refresh_request(value: Any) -> FieldRefreshRequest

  Validate one refresh request strictly; unknown members are rejected.

• parse_legacy_form_populate_request(value: Any) -> LegacyFormPopulateRequest

  Validate one JSON-compatible legacy form population request.

• populate_legacy_form_fields(request: LegacyFormPopulateRequest) -> LegacyFormPopulateReport

  Populate source-bound legacy form text and checkbox results atomically.

• refresh_fields(request: FieldRefreshRequest) -> FieldRefreshReport

  Refresh every selected field's cached result and publish one verified package.

• FieldCode (enum) Word's documented numeric field catalog, independent of evaluation support.
• FieldOptions (dataclass) How one refresh writes its values.
• FieldRefreshReport(status: str, code: str | None, source_sha256: str | None, refreshed: list[dict[str, Any]], unsupported: list[dict[str, Any]], unrefreshed: list[dict[str, Any]], parts: list[str], iterations: int, converged: bool, boundaries: list[str], pages: int | None, destination_sha256: str | None, unselected_parts_preserved: bool | None, fonts: list[dict[str, Any]], limits: dict[str, int] | None, evaluation_time: str | None = ...) (dataclass) The receipt of one refresh: published values, or a structured refusal.
• FieldRefreshRequest(source: Path, source_sha256: str, output: Path, part: str = ..., fields: tuple[FieldTarget, ...] = ..., fonts: tuple[FontAsset, ...] = ..., limits: RenderLimits = ..., options: FieldOptions = ..., evaluation_time: str | None = ..., result_formatter: Callable[[FieldResultFormatContext], str | None] | None = ..., merge_values: Mapping[str, Any] | None = ..., progress_callback: Callable[[Field], None] | None = ..., external_provider: Callable[[ExternalFieldDetails], str] | None = ..., barcode_generator: Callable[[BarcodeFieldDetails], bytes] | None = ..., progress_observer: Callable[[FieldProgress], bool | None] | None = ...) (dataclass) One source-bound refresh, with explicit fonts for page-dependent values.
• FieldTarget (dataclass) One field a caller selected, bound to the source by its structure digest.
• LegacyFormFieldTarget (dataclass) One discoverable legacy ``w:ffData`` form field bound to its source field.
• LegacyFormFieldUpdate (dataclass) One exact legacy form field descriptor plus the text or checked value to write.
• LegacyFormPopulateReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, updated: list[dict[str, Any]], non_target_parts_preserved: bool | None, unrelated_paragraphs_preserved: bool | None) (dataclass) The receipt for a published legacy form population request or its refusal.
• LegacyFormPopulateRequest(source: Path, destination: Path, source_sha256: str, updates: tuple[LegacyFormFieldUpdate, ...]) (dataclass) A source-bound, atomic request to populate legacy Word form fields.

wolfdocx.find_replace

• discover_matches(source: str | Path, pattern: str, *, part: str = 'word/document.xml', options: FindReplaceOptions | Mapping[str, Any] | None = None) -> dict[str, Any]

  Read regex matches, including inline wrappers, revisions and field instructions.

• find_replace(request: FindReplaceRequest, *, verify: str = 'full') -> FindReplaceReport

  Execute atomic regex find and replace across runs and consecutive paragraphs.

• load_find_replace_request(path: str | Path) -> FindReplaceRequest

  Load and validate a JSON FindReplaceRequest from disk.

• parse_find_replace_request(data: Any) -> FindReplaceRequest

  Parse and validate a dictionary representation of a FindReplaceRequest.

• FindReplaceOptions (dataclass) Configuration options for regex find and replace operations.
• FindReplaceReport(status: str, code: str | None, source_sha256: str, destination: str | None, match_count: int, replacement_count: int, matches: list[dict[str, Any]], unselected_parts_preserved: bool) (dataclass) The receipt of one find and replace operation.
• FindReplaceRequest (class) One bounded find and replace operation over a DOCX package.

wolfdocx.flow_pdf

• html_to_pdf(html: str, output: str | Path, *, fonts: Sequence[FontAsset], monospace_family: str | None = None, limits: RenderLimits | None = None, save_options: RenderSaveOptions | None = None) -> FlowPdfReport

  Lay out one HTML document natively and publish it as a new PDF at ``output``.

• markdown_to_pdf(markdown: str, output: str | Path, *, fonts: Sequence[FontAsset], monospace_family: str | None = None, limits: RenderLimits | None = None, save_options: RenderSaveOptions | None = None) -> FlowPdfReport

  Lay out CommonMark plus GFM tables natively and publish a new PDF at ``output``.

• FlowPdfReport(status: str, code: str | None, source_format: str, source_sha256: str, output: str | None, output_sha256: str | None, pages: int, omissions: list[str], boundaries: list[str], package_sha256: str | None) (dataclass) Result of one Markdown or HTML to PDF publication.

wolfdocx.font_sources

• FontSource (dataclass) One file, folder, named buffer or Python-only bounded stream (see module API).

wolfdocx.formatting

• author_format(request: FormatRequest) -> FormatReport

  Execute source-bound run and paragraph formatting changes atomically.

• discover_format_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  List source-bound paragraph targets and available styles without writing.

• load_format_request(path: str | Path) -> FormatRequest

  Load a formatting authoring request from a UTF-8 JSON file.

• parse_format_request(value: Any) -> FormatRequest

  Parse the strict JSON request for atomic formatting authoring operations.

• FormatReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, run_edits: list[dict[str, Any]], paragraph_edits: list[dict[str, Any]], changed_targets: list[dict[str, Any]]) (dataclass) Content-safe public receipt for one atomic formatting authoring request.
• FormatRequest(source: Path, source_sha256: str, destination: Path, run_edits: tuple[RunFormatEdit, ...] = ..., paragraph_edits: tuple[ParagraphFormatEdit, ...] = ...) (dataclass) Strict request for source-bound paragraph and run formatting changes.
• IndentSpec (dataclass) Paragraph indentation specification in twips.
• ParagraphBordersSpec (dataclass) Paragraph border specification across supported sides.
• ParagraphFormatEdit (dataclass) Selective paragraph formatting change anchored to a source-bound paragraph.
• RunFormatEdit (dataclass) Selective formatting anchored to a source-bound base-text character range.
• SpacingSpec (dataclass) Paragraph spacing specification in twips / line-rules.

wolfdocx.gate

• run_gate(policy: str | Path, *, output_dir: str | Path, expected_policy_sha256: str | None = None, validator_project: str | Path = <absolute-path>, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', timeout_seconds: int = 120, schema_validator: SchemaValidator = <callable>, visual_comparator: VisualComparator = <callable>, policy_display_path: str | None = None) -> GateReport

• GateIssue (dataclass)
• GateReport(gate_id: str | None, policy_path: str, policy_sha256: str, evidence_dir: str, inputs: dict[str, dict[str, Any]] = ..., lanes: dict[str, dict[str, Any]] = ..., issues: list[GateIssue] = ..., report_path: str | None = ...) (dataclass)

wolfdocx.generation

• generate_document(request: GenerationRequest) -> GenerationReport

  Publish one verified generated document or one explicit refusal.

• load_generation_request(path: str | Path) -> GenerationRequest
• parse_generation_request(value: Any) -> GenerationRequest

  Parse the strict JSON request for one atomic generation operation.

• GenerationReport(status: str, code: str | None, failed_step: int | None, source_sha256: str, data_sha256: str, output_sha256: str | None, steps: list[dict[str, Any]] = ...) (dataclass) Content-safe public result for one generation request.
• GenerationRequest(source: Path, source_sha256: str, output: Path, data: Any, data_sha256: str, data_file_sha256: str | None, data_path: Path | None, plan: tuple[Any, ...]) (dataclass) One atomic generation request bound to an authored source document.

wolfdocx.html_export

• docx_to_html(source: str | Path, options: HtmlSaveOptions | None = None, *, report: list[dict[str, object]] | None = None) -> str

  Export the main document body to a self-contained, deterministic HTML5 page.

• docx_to_html_parts(source: str | Path, options: HtmlSaveOptions | None = None, *, report: list[dict[str, object]] | None = None) -> tuple[HtmlDocument, ...]

  Export immutable named standalone HTML documents without network access.

• HtmlDocument (dataclass) One immutable standalone HTML/XHTML document and its encoded byte output.
• HtmlExportError (exception) A save-option refusal, with a stable machine-readable ``code``.
• HtmlResource (dataclass) An immutable callback payload and optional output directive.
• HtmlSaveOptions (dataclass) Deterministic HTML export policy; string values are case-sensitive.

wolfdocx.inspect

• inspect_docx(path: str | Path, *, limits: PackageLimits | None = None, profile: PackageProfile | None = None) -> InspectionReport

• InspectionReport(path: str, file_sha256: str, limits: dict[str, int | float] = ..., issues: list[Issue] = ..., parts: list[PartInfo] = ..., fingerprint: DocumentFingerprint = ..., active_content: dict[str, Any] = ..., part_texts: dict[str, str] = ...) (dataclass)
• PackageLimits (dataclass)

wolfdocx.layout_targets

• crop_layout(source: str | Path, *, source_sha256: str, fonts: Sequence[TrueTypeFont], selector: LayoutSelector | LayoutObjectSelector, output_dir: str | Path, scale: float = 2.0, aliases: Mapping[str, str] | None = None, limits: RenderLimits | None = None) -> LayoutCrop

  Publish the exact native pixel crop of one selected editable or image object.

• diagnose_layout(source: str | Path, *, source_sha256: str, fonts: Sequence[TrueTypeFont], aliases: Mapping[str, str] | None = None, limits: RenderLimits | None = None) -> LayoutDiagnosis

  Report the observable geometry facts of one bound source's native layout.

• discover_layout_targets(source: str | Path, *, source_sha256: str, fonts: Sequence[TrueTypeFont], aliases: Mapping[str, str] | None = None, limits: RenderLimits | None = None) -> LayoutInventory

  Inventory every object one bound source's native layout drew.

• layout_crop(request: LayoutCropRequest) -> LayoutCrop

  Run one bound crop request, loading the fonts it explicitly names.

• layout_diagnose(request: LayoutRequest) -> LayoutDiagnosis

  Run one bound diagnostic request, loading the fonts it explicitly names.

• layout_resolve(request: LayoutRequest) -> LayoutResolution

  Run one bound resolution request, loading the fonts it explicitly names.

• layout_targets(request: LayoutRequest) -> LayoutInventory

  Run one bound inventory request, loading the fonts it explicitly names.

• load_layout_crop_request(path: str | Path) -> LayoutCropRequest
• load_layout_request(path: str | Path) -> LayoutRequest
• load_layout_resolve_request(path: str | Path) -> LayoutRequest
• parse_layout_crop_request(value: Any) -> LayoutCropRequest

  Validate one crop request strictly; unknown keys are rejected.

• parse_layout_request(value: Any) -> LayoutRequest

  Validate one inventory or diagnostic request strictly; unknown keys are rejected.

• parse_layout_resolve_request(value: Any) -> LayoutRequest

  Validate one resolution request strictly: a bound source plus its selector.

• resolve_layout_target(source: str | Path, *, source_sha256: str, fonts: Sequence[TrueTypeFont], selector: LayoutSelector, aliases: Mapping[str, str] | None = None, limits: RenderLimits | None = None) -> LayoutResolution

  Resolve one page point or rectangle to the single source object it selects.

• LayoutCrop (dataclass) The receipt of one crop: the selected object, its exact region, and its artifact.
• LayoutCropRequest(source: Path, source_sha256: str, fonts: tuple[FontAsset, ...], output_dir: Path, selector: LayoutSelector | LayoutObjectSelector, scale: float = ..., limits: RenderLimits = ...) (dataclass) One bound crop: a checked source, explicit fonts, a selector, and a destination.
• LayoutDiagnosis (dataclass) The receipt of one layout analysis: overflow, overlap, and pagination facts.
• LayoutInventory (dataclass) The receipt of one layout inventory: every drawn object of one bound source.
• LayoutObject (dataclass) One source object this layout drew, with its occurrences and its target.
• LayoutObjectSelector (dataclass) One strict object selector: a source-versioned inventory key and its occurrence.
• LayoutOccurrence (dataclass) One page this source object was drawn on, and the box it was drawn into.
• LayoutRequest(source: Path, source_sha256: str, fonts: tuple[FontAsset, ...], limits: RenderLimits = ..., selector: LayoutSelector | None = ...) (dataclass) One bound layout request: a checked source, explicit fonts, and its bounds.
• LayoutResolution (dataclass) The receipt of one geometry resolution: one target, or an explicit outcome.
• LayoutSelector (dataclass) One strict page selector: a point, or a rectangle, in page points.

wolfdocx.legacy_doc_export

• docx_to_doc(source: str | Path, *, password_to_open: str | None = None, password_to_modify: str | None = None, picture_bullets: bool = <sentinel>, always_compressed_metafiles: bool = <sentinel>, options: DocSaveOptions | None = None) -> bytes

  Return Word 97--2003 DOC bytes, optionally protected with RC4 CryptoAPI.

• export_doc(source: str | Path, output: str | Path, *, password_to_open: str | None = None, password_to_modify: str | None = None, picture_bullets: bool = <sentinel>, always_compressed_metafiles: bool = <sentinel>, options: DocSaveOptions | None = None) -> LegacyDocExportReport

  Publish DOC using :func:`docx_to_doc` options without clobbering output.

• DocSaveOptions (dataclass) Word 97--2003 policy, retaining the existing native writer's fidelity.
• LegacyDocExportError (exception) Raised when input is outside the native DOC writer subset.

wolfdocx.links

• author_hyperlink(request: HyperlinkRequest) -> HyperlinkReport

  Resolve all hyperlink edits on the immutable source, verify once, and publish once.

• discover_hyperlink_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inspect and inventory source-bound hyperlink targets and editable paragraph ranges.

• load_hyperlink_request(path: str | Path) -> HyperlinkRequest

  Load and strictly validate a hyperlink authoring request from JSON on disk.

• parse_hyperlink_request(value: Any) -> HyperlinkRequest

  Parse the strict JSON request for one atomic hyperlink authoring operation.

• HyperlinkDelete (dataclass) One bound hyperlink deletion over an explicitly selected paragraph hyperlink range.
• HyperlinkInsert (dataclass) One bound hyperlink insertion over an explicitly selected paragraph text range.
• HyperlinkReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, hyperlinks: list[dict[str, Any]], changed_targets: list[dict[str, Any]]) (dataclass) Content-safe public result for a hyperlink authoring request.
• HyperlinkRequest(source: Path, source_sha256: str, destination: Path, edits: tuple[HyperlinkEdit, ...]) (dataclass) Strict request for one atomic, verified hyperlink authoring operation.
• HyperlinkTarget (dataclass) One discovered or targetable hyperlink site in a document paragraph.
• HyperlinkUpdate (dataclass) One bound hyperlink destination update over an explicitly selected paragraph hyperlink range.

wolfdocx.linq_reporting

• build_linq_report(source: str | Path, destination: str | Path, data: Mapping[str, Any], *, source_sha256: str | None = None, options: LinqReportingBuildOptions = LinqReportingBuildOptions(missing_member='error', remove_empty_paragraphs=False, inline_error_messages=False, known_types=()), context: ProcessorContext | None = None) -> LinqReportingReport

  Expand one source-bound template and atomically publish its report.

• render_linq_report(request: LinqReportingRequest, *, context: ProcessorContext | None = None) -> LinqReportingReport

  Render supported tags or leave both source and destination untouched.

• CsvDataSource (dataclass) CSV records, with a zero-based header row or generated ``column1`` names.
• JsonDataSource (dataclass) JSON with explicit root selection and Python ``strptime`` date formats.
• LinqReportingBuildOptions (dataclass) Opt-in policies; defaults preserve the original rendering byte-for-byte.
• LinqReportingReport(status: str, code: str | None, source_sha256: str | None, destination_sha256: str | None, template_tags: int, changed_parts: tuple[str, ...], unselected_parts_preserved: bool) (dataclass) Receipt for one report expansion, including refusals that publish nothing.
• LinqReportingRequest(source: Path, destination: Path, source_sha256: str, data: Mapping[str, Any], options: LinqReportingBuildOptions = ...) (dataclass) An immutable source binding and caller-owned data for one output document.
• ReportingDataSourceError (exception) A data source cannot be loaded; ``code`` is stable and contains no paths.
• XmlDataSource (dataclass) XML with explicit root wrapping; repeated children become lists.

wolfdocx.load_options

• LoadOptions (dataclass) Options every open and import path accepts.
• ProcessorContext (dataclass) Shared policies for conversion, assembly, splitting and template processing.

wolfdocx.mail_merge

• discover_mail_merge_targets(source: str | Path, *, use_mustache: bool = False) -> dict[str, Any]

  Inventory the merge fields of reachable stories without changing a package.

• load_mail_merge_request(path: str | Path) -> MailMergeRequest
• merge_documents(request: MailMergeRequest, *, context: ProcessorContext | None = None) -> MailMergeReport

  Merge every record of one bound data document into one recipient document each.

• parse_mail_merge_request(value: Any) -> MailMergeRequest

  Validate one mail-merge request strictly; unknown members are rejected.

• MailMergeCallbackContext (dataclass) One live occurrence; ``missing`` distinguishes absence from supplied null.
• MailMergeInsertionCursor (class) Replace an occurrence through the existing builder and node importer.
• MailMergeRecord (dataclass) One recipient's safe identifier and the explicit text of its merge fields.
• MailMergeReport(status: str, code: str | None, source_sha256: str | None, data_sha256: str | None, output_dir: str | None, field_names: list[str], fields: list[dict[str, Any]], unsupported: list[dict[str, Any]], other_stories: list[dict[str, Any]], recipients: list[dict[str, Any]], counts: dict[str, int], boundaries: list[str], recovery: str | None, staging: dict[str, Any] | None, destination: dict[str, Any] | None, limits: dict[str, int]) (dataclass) The receipt of one batch: the published recipients, or a structured refusal.
• MailMergeRequest(source: Path, source_sha256: str, output_dir: Path, data_sha256: str, data_path: Path, data_file_sha256: str, field_mapping: Mapping[str, str] = ..., use_mustache: bool = ..., cleanup: frozenset[str] = ..., field_callback: Callable[[str, Any, Mapping[str, Any]], Any] | None = ..., database_provider: Callable[[Mapping[str, Any]], Mapping[str, Any] | DatabaseTable] | None = ..., data_provider: Callable[[Mapping[str, Any]], Mapping[str, Any] | DatabaseTable] | None = ..., locale_config: Mapping[str, Any] = ..., live_field_callback: Callable[[MailMergeCallbackContext], Any] | None = ..., region_source_resolver: Callable[[str, Mapping[str, Any]], PullMergeSource | None] | None = ...) (dataclass) One source-bound batch mail merge over one explicit data document.
• PullMergeSource (class) Caller-owned, forward-only records for one region occurrence.

wolfdocx.markdown

• docx_to_markdown(source: str | Path, *, options: MarkdownExportOptions | None = None, image_saving_callback: Callable[[bytes, str], str | None] | None = None) -> str

  Export Markdown; warn once per omission instead of silently losing content.

• docx_to_markdown_report(source: str | Path, *, options: MarkdownExportOptions | None = None, image_saving_callback: Callable[[bytes, str], str | None] | None = None) -> MarkdownExportReport

  Export with deterministic occurrence-level content and formatting omissions.

• MarkdownExportError (exception) Invalid Markdown save configuration, with a stable refusal ``code``.
• MarkdownExportOptions (dataclass) Immutable shared save-model policy; defaults preserve historic bytes.

wolfdocx.native_fonts

• NativeFontError (exception) One explicit font refusal carrying a bounded code.
• TrueTypeFont (class) One standalone TrueType or OpenType CFF1 font, with digest-bound identity.

wolfdocx.native_layout

• ImageItem (dataclass) One image drawn from the exact source bytes of its package part.
• Layout (dataclass) The resolved document: pages, boundaries, fonts, and source semantics.
• LineBox (dataclass) One laid-out line of text, reported for inspection and tests.
• NativeLayoutError (exception) One explicit layout refusal carrying a bounded code.
• Page (dataclass) One resolved page: geometry, drawn items, and reported lines.
• RectItem (dataclass) One filled rectangle in page points, used for rules and shading.
• RenderLimits (dataclass) Bounds that keep one native render operation predictable.
• TextItem (dataclass) One positioned run of glyphs sharing a font, size, and colour.

wolfdocx.native_render

• layout_native_document(source: str | Path, fonts: Sequence[TrueTypeFont], *, aliases: Mapping[str, str] | None = None, limits: RenderLimits | None = None, font_substitutions: Mapping[str, Sequence[str]] | None = None, default_font: str | None = None, substitution_records: list[dict[str, Any]] | None = None, options: LayoutOptions | None = None, font_fallback_settings: Mapping[str, Any] | None = None, font_info_substitution: Mapping[str, Any] | None = None, numeral_format: str | None = None, fontconfig_substitution: bool = False) -> Layout

  Resolve pages; optional plain-body numeral shaping never edits source bytes.

• load_font_assets(assets: Sequence[FontAsset], limits: RenderLimits | None = None) -> tuple[tuple[TrueTypeFont, ...], dict[str, str]]

  Load explicitly supplied font files and their declared-family aliases.

• load_native_render_request(path: str | Path) -> NativeRenderRequest
• parse_native_render_request(value: Any) -> NativeRenderRequest

  Validate strict JSON settings; callable layout callbacks are never admitted.

• render_native(request: NativeRenderRequest) -> NativeRenderReport

  Publish a complete layout atomically, refusing stops and propagating caller failures.

• FontAsset (dataclass) One explicitly supplied local font asset and the family a document names.
• NativeRenderError (exception) One explicit publication refusal carrying a bounded code.
• NativeRenderReport(status: str, code: str | None, source_sha256: str, output_dir: str | None, formats: list[str], scale: float, pages: int, files: list[dict[str, Any]], fonts: list[dict[str, Any]], boundaries: list[str], limits: dict[str, int], stats: dict[str, int], resolved_assets: list[dict[str, Any]] | None = ..., substitutions: list[dict[str, Any]] | None = ..., options: dict[str, Any] | None = ...) (dataclass) The receipt for one native render: status, digests, fonts, and boundaries.
• NativeRenderRequest(source: Path, source_sha256: str, output_dir: Path, fonts: tuple[FontAsset, ...], formats: tuple[str, ...], scale: float, limits: RenderLimits, pdfa: str | None = ..., pdf_encryption: PdfEncryption | None = ..., pdfua: bool | str = ..., pages: tuple[int, ...] | None = ..., dpi: float | None = ..., colour_mode: str | None = ..., binarization: Mapping[str, Any] | None = ..., tiff_compression: str | None = ..., page_mode: str | None = ..., page_layout: str | None = ..., open_action_zoom: str | float | None = ..., outline_heading_levels: tuple[int, ...] | None = ..., outline_expanded_levels: int | None = ..., outline_create_missing_levels: bool | None = ..., header_footer_bookmark_mode: str | None = ..., bookmark_mode: str | None = ..., custom_property_export: str | None = ..., image_downsampling: Mapping[str, Any] | None = ..., font_sources: tuple[FontSource, ...] = ..., use_system_fonts: bool = ..., font_substitutions: Mapping[str, Sequence[str]] | None = ..., default_font: str | None = ..., pdf_signature: PdfSignature | None = ..., pdf_image_colour_space: str | None = ..., pdf_colour_space: str | None = ..., pdf_embed_attachments: bool = ..., pdf_font_embedding: str | None = ..., pdf_text_compression: bool | None = ..., pdf_attachment_annotations: bool = ..., comments: str = ..., revisions_view: str = ..., revisions: RevisionOptions | None = ..., metafile_rendering_mode: str | None = ..., dml_rendering_mode: str | None = ..., dml_effects_rendering_mode: str | None = ..., dml_3d_effects_rendering_mode: str | None = ..., emf_plus_dual_rendering_mode: str | None = ..., ink_rendering_mode: str | None = ..., svg_text_output_mode: str | None = ..., numeral_format: str | None = ..., font_fallback_settings: Mapping[str, Any] | None = ..., font_info_substitution: Mapping[str, Any] | None = ..., layout_callback: Callable[[PageLayoutEvent], None] | None = ..., balance_columns: bool = ..., save_options: RenderSaveOptions | None = ..., page_range: tuple[int, int] | PageRange | None = ..., pixel_format: str | None = ..., jpeg_quality: int | None = ..., pdf_image_compression: str | None = ..., bookmark_outline_levels: Mapping[str, int] | None = ..., bookmark_default_level: int | None = ..., page_set: str | None = ..., horizontal_resolution: float | None = ..., vertical_resolution: float | None = ..., image_size: tuple[int, int] | None = ..., brightness: float | None = ..., contrast: float | None = ..., paper_color: str | None = ..., tiff_layout: str | None = ..., pdf_version: str | None = ..., svg_resource_folder: str | None = ..., svg_resource_callback: Callable[[SvgResource], str | None] | None = ..., svg_id_prefix: str | None = ..., svg_fit_viewport: bool | None = ..., svg_show_page_border: bool | None = ..., svg_image_resolution: float | None = ..., page_saving_callback: Callable[[PageSavingEvent], Any] | None = ..., anti_aliasing: bool | None = ..., high_quality_rendering: bool | None = ..., font_settings: FontSettings | None = ..., fontconfig_substitution: bool = ..., font_warning_callback: Callable[[dict[str, str]], None] | None = ...) (dataclass) One bound render with digest-recorded assets and a new destination.
• RenderFile (dataclass) One published artifact with its digest.
• RenderSaveOptions (dataclass) Immutable native SVG, raster and PDF publication policy.

wolfdocx.notes

• author_note(request: NoteRequest) -> NoteReport

  Execute one atomic, verified footnote or endnote authoring operation.

• discover_note_targets(source: str | Path, kind: str = 'footnote') -> dict[str, Any]

  Inspect and inventory source-bound note insertion targets and existing note definitions.

• load_note_request(path: str | Path) -> NoteRequest

  Load and strictly validate a note authoring request from JSON on disk.

• parse_note_request(value: Any) -> NoteRequest

  Parse the strict JSON request for one atomic footnote or endnote authoring operation.

• NoteReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, notes: list[dict[str, Any]], changed_targets: list[dict[str, Any]]) (dataclass) Content-safe public result for a footnote or endnote authoring request.
• NoteRequest(source: Path, source_sha256: str, destination: Path, kind: str, paragraph: int | None = ..., start: int | None = ..., end: int | None = ..., expected_old_text: str | None = ..., structure_fingerprint_sha256: str | None = ..., text: str | None = ..., reference_run_properties: Mapping[str, Any] | None = ..., part: str = ..., anchor_boundary: str = ..., action: str = ..., note_id: int | None = ..., content_fingerprint_sha256: str | None = ..., custom_mark: str | None = ..., options: Mapping[str, Any] | None = ..., section: int | None = ..., separator_type: str | None = ..., separator_border: Mapping[str, Any] | None = ...) (dataclass) Strict request for one atomic, verified footnote or endnote authoring operation.

wolfdocx.numbering_authoring

• author_numbering(request: NumberingRequest) -> NumberingReport

  Execute source-bound paragraph numbering mutations atomically.

• discover_numbering_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  List source-bound paragraph targets, existing abstract definitions, and instances.

• load_numbering_request(path: str | Path) -> NumberingRequest

  Load and strictly validate a numbering authoring request from JSON on disk.

• parse_numbering_request(value: Any) -> NumberingRequest

  Parse the strict JSON request for one atomic numbering authoring operation.

• NumberingEdit (dataclass) One source-bound paragraph numbering mutation.
• NumberingReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, numbering: list[dict[str, Any]], changed_targets: list[dict[str, Any]]) (dataclass) Content-safe public result for a numbering authoring request.
• NumberingRequest(source: Path, source_sha256: str, destination: Path, edits: tuple[NumberingEdit, ...]) (dataclass) Strict request for one atomic, verified numbering authoring operation.

wolfdocx.numbering_definition

• author_numbering_definition(request: NumberingDefinitionRequest) -> NumberingDefinitionReport

  Execute creation of a reusable numbering definition in word/numbering.xml.

• discover_numbering_definition_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory existing numbering definitions, IDs, creation availability, and paragraph targets.

• load_numbering_definition_request(path: str | Path) -> NumberingDefinitionRequest

  Load and strictly validate a numbering definition authoring request from JSON on disk.

• numbering_definition_structure_fingerprint(element: ET.Element) -> str

  Deterministic structural SHA-256 fingerprint for a numbering element.

• parse_numbering_definition_request(value: Any) -> NumberingDefinitionRequest

  Parse and strictly validate a numbering definition authoring request from a dictionary.

• NumberingDefinitionReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., definition: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ..., boundaries: list[str] = ...) (dataclass) Content-safe public result for a numbering definition authoring operation.
• NumberingDefinitionRequest(source: Path, destination: Path, source_sha256: str, definition: NumberingDefinitionSpec) (dataclass)
• NumberingDefinitionSpec (dataclass) Numbering definition containing one or more ordered level specifications.
• NumberingLevelSpec (dataclass) Explicit level configuration for a numbering definition.

wolfdocx.odt

• docx_to_odt(source: str | Path, output: str | Path, *, measure_unit: str = 'centimetres', odf_version: str = '1.2', pretty_print: bool = <sentinel>, password_to_open: str | None = None, password_to_modify: str | None = None, options: OdtSaveOptions | None = None) -> OdtExportReport

  Export supported DOCX body content to a new compliant ODT archive.

• odt_to_docx(source: str | Path, output: str | Path) -> OdtImportReport

  Import unencrypted ODT; encrypted packages refuse before parsing ciphertext.

• OdtConversionError (exception) An ODT or DOCX construct outside the admitted conversion subset.
• OdtSaveOptions (dataclass) Immutable ODF body-export, password, and RSA/X.509 signing policy.

wolfdocx.operations

• analyze_package(request: PackageAnalysisRequest) -> PackageAnalysis

  Analyze one package once and share its graph across declared lanes.

• inspect_and_diff(baseline: str | Path, candidate: str | Path, *, allowed_categories: Iterable[str] = ()) -> InspectionDiffResult

  Inspect two documents once each, then compare their semantic reports.

• inspection_execution_error(report: InspectionReport) -> bool

  Whether inspection failed before a document-level decision was possible.

• AnalysisSession (class) One graph and a private, reconcilable resource ledger for its analysis lanes.
• InspectionDiffResult (dataclass) The inspected inputs and semantic diff produced by :func:`inspect_and_diff`.
• PackageAnalysis (dataclass) All analysis lanes derived from one package-analysis session.
• PackageAnalysisRequest(path: str | Path, content_assertions: tuple[ContentAssertion, ...] = ..., limits: PackageLimits | None = ..., profile: PackageProfile | None = ...) (dataclass) One package and its declared semantic checks for shared analysis.

wolfdocx.output

• publish_verified_outputs(source_directory: str | os.PathLike[str], destination_directory: str | os.PathLike[str], declarations: Sequence[OutputDeclaration], *, owner_uid: int) -> OutputPublicationReceipt

  Atomically publish only previously verified regular files.

• verify_output_allowlist(source_directory: str | os.PathLike[str], declarations: Sequence[OutputDeclaration], *, owner_uid: int) -> OutputPublicationReceipt

  Verify a hostile worker output tree without publishing any file.

• CompressionLevel (enum)
• OoxmlCompliance (enum)
• OoxmlSaveOptions (dataclass) Explicit namespace conversion and deterministic ZIP container policy.
• OutputAllowlistError (exception) A safe output-boundary rejection that exposes no filesystem detail.
• OutputDeclaration (dataclass) One caller-declared regular-file output contract.
• OutputPublicationReceipt (dataclass) Path-safe verified identities for every published output.
• SaveOptions (dataclass) Shared immutable model for every format's save policy.
• SaveOptionsError (exception) Invalid save configuration or content that cannot be exported faithfully.
• TxtExportHeadersFootersMode (enum)
• TxtListIndentation (dataclass) Repeat ``character`` ``count`` times per zero-based list nesting level.
• TxtOfficeMathExportMode (enum)
• TxtSaveOptions (dataclass) TXT wrapping, bidi, table alignment, list, math and story placement policy.
• Zip64Mode (enum)

wolfdocx.package_profile

• load_package_profile(path: str | Path) -> PackageProfile

  Load a profile JSON file through the strict JSON and profile boundaries.

• parse_package_profile(value: object) -> PackageProfile

  Parse one exact versioned profile mapping without coercion or implicit fields.

• PackageMemoryBounds (dataclass) Explicit upper bound on uncompressed DOCX bytes retained during inspection.
• PackageProfile (dataclass) Versioned package-execution profile with no unbounded resource defaults.
• PackageProfileError (exception) Raised when a package resource profile is not an exact bounded configuration.

wolfdocx.page_setup

• author_page_setup(request: PageSetupRequest) -> PageSetupReport

  Modify selected section page setup geometry atomically and verification-checked.

• discover_page_setup_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate section targets for page setup authoring.

• load_page_setup_request(path: str | Path) -> PageSetupRequest

  Load and strictly validate one JSON page-setup request from disk.

• page_setup_structure_fingerprint(source: str | Path, *, section: int = 1, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for one exact section.

• parse_page_setup_request(value: Any) -> PageSetupRequest

  Parse and strictly validate a page setup authoring request.

• ColumnsSpec (dataclass) Column configuration; explicit widths select w:equalWidth='0'.
• FootnotePropertiesSpec (dataclass) Section footnote numbering in WordprocessingML (w:footnotePr, ECMA-376 17.11.11).
• LineNumberingSpec (dataclass) Explicit section line numbering configuration in WordprocessingML.
• MarginsSpec (dataclass) Page margins in twips.
• PageNumberingSpec (dataclass) Explicit section page numbering configuration in WordprocessingML (w:pgNumType).
• PageSetupReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., page_setup: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ..., native_column_layout_supported: bool | None = ...) (dataclass) Content-safe public report for one page setup authoring operation.
• PageSetupRequest(source: Path, destination: Path, source_sha256: str, structure_fingerprint_sha256: str, section: int = ..., page_size: PageSizeSpec | None = ..., orientation: str | None = ..., margins: MarginsSpec | None = ..., columns: ColumnsSpec | None = ..., page_numbering: PageNumberingSpec | None = ..., line_numbering: LineNumberingSpec | None = ..., different_first_page: bool | None = ..., different_odd_and_even_pages: bool | None = ..., vertical_alignment: str | None = ..., page_borders: PageBordersSpec | None = ..., part: str = ..., footnote_properties: FootnotePropertiesSpec | Mapping[str, Any] | None = ..., document_grid: Mapping[str, Any] | None = ...) (dataclass) Strict request for modifying page setup on one source-bound section.
• PageSetupTarget (dataclass) Discovered section page setup candidate target.
• PageSizeSpec (dataclass) Explicit page size dimensions in twips.

wolfdocx.paragraph_authoring

• author_paragraph(request: ParagraphRequest, *, verify: str = 'full') -> ParagraphReport

  Insert or delete a body or referenced header/footer paragraph atomically and verification-checked.

• discover_paragraph_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate body or header/footer paragraphs for authoring.

• load_paragraph_request(path: str | Path) -> ParagraphRequest

  Load and strictly validate one JSON paragraph request from disk.

• paragraph_authoring_structure_fingerprint(source: str | Path, *, paragraph: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural anchor fingerprint for one exact body or header/footer paragraph.

• parse_paragraph_request(value: Any) -> ParagraphRequest

  Parse and strictly validate a paragraph authoring request.

• ParagraphReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., action: str | None = ..., paragraph: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a body paragraph authoring request.
• ParagraphRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, action: str = ..., position: str | None = ..., text: str | None = ..., style: str | None = ..., offset: int | None = ...) (dataclass) One source-bound request to insert, delete, or split a body paragraph.
• ParagraphTarget (dataclass) One candidate body paragraph target for authoring.

wolfdocx.picture_delete

• author_picture_delete(request: PictureDeleteRequest) -> PictureDeleteReport

  Delete one exact source-bound picture and atomically publish the result.

• discover_picture_delete_targets(source: str | Path, *, part: str | None = None) -> dict[str, Any]

  Inventory candidate inline and anchored picture targets in the document body and reachable headers/footers.

• load_picture_delete_request(path: str | Path) -> PictureDeleteRequest

  Load one UTF-8 JSON picture delete authoring request.

• parse_picture_delete_request(value: Any) -> PictureDeleteRequest

  Parse and validate the strict JSON request for one atomic picture deletion operation.

• picture_delete_structure_fingerprint(source: str | Path, *, paragraph: int, drawing: int = 1, part: str = 'word/document.xml') -> str | None

  Return the bounded picture structural fingerprint for request construction.

• PictureDeleteReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., deleted_picture: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Report of one source-bound picture deletion operation.
• PictureDeleteRequest(source: Path, source_sha256: str, destination: Path, target: Mapping[str, Any], structure_fingerprint_sha256: str, expected_extent_cx: int | None = ..., expected_extent_cy: int | None = ..., expected_media_sha256: str | None = ...) (dataclass) Strict request for deleting one source-bound inline or anchored picture.
• PictureDeleteTarget (dataclass) One discovered candidate picture target for deletion.

wolfdocx.picture_insert

• author_picture_insert(request: PictureInsertRequest) -> PictureInsertReport

  Insert one caller-provided inline or anchored picture and atomically publish it.

• discover_picture_insert_targets(source: str | Path, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory supported body or referenced header/footer paragraph anchors for picture insertion.

• load_picture_insert_request(path: str | Path) -> PictureInsertRequest

  Load one UTF-8 JSON picture insert authoring request.

• parse_picture_insert_request(value: Any) -> PictureInsertRequest

  Parse the strict JSON request for inserting an inline or anchored picture.

• picture_insert_structure_fingerprint(source: str | Path, *, paragraph: int, part: str = 'word/document.xml') -> str | None

  Return the bounded paragraph structural fingerprint for request construction.

• PictureAnchorSpec (dataclass) Position and layering specification for page-relative anchored picture insertion.
• PictureInsertReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, target: dict[str, Any] | None, target_change_report: dict[str, Any] | None, non_target_parts_preserved: bool | None) (dataclass) Report of one picture insertion operation.
• PictureInsertRequest(source: Path, source_sha256: str, destination: Path, paragraph: int, structure_fingerprint_sha256: str, image_path: Path, image_sha256: str, extent_cx: int | None = ..., extent_cy: int | None = ..., alt_text: str | None = ..., anchor: PictureAnchorSpec | None = ..., part: str = ..., fallback_path: Path | None = ..., fallback_sha256: str | None = ...) (dataclass) Strict request for inserting one bounded inline or anchored picture into a paragraph.
• PictureInsertTarget (dataclass) One discovered candidate paragraph anchor for picture insertion.

wolfdocx.picture_resize

• author_picture_resize(request: PictureResizeRequest) -> PictureResizeReport

  Resize one source-bound picture or inline AutoShape's declared extents and publish.

• discover_picture_resize_targets(source: str | Path, *, part: str | None = None) -> dict[str, Any]

  Inventory picture and inline AutoShape resize targets in body and reachable stories.

• load_picture_resize_request(path: str | Path) -> PictureResizeRequest

  Load one UTF-8 JSON picture resize authoring request.

• parse_picture_resize_request(value: Any) -> PictureResizeRequest

  Parse the strict JSON request for resizing one source-bound picture's extent.

• PictureResizeReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, target: dict[str, Any] | None, target_change_report: dict[str, Any] | None, non_target_parts_preserved: bool | None) (dataclass) Report of one picture extent resize operation.
• PictureResizeRequest(source: Path, source_sha256: str, destination: Path, structure_fingerprint_sha256: str, target: dict[str, Any], extent_cx: int, extent_cy: int, expected_extent_cx: int | None = ..., expected_extent_cy: int | None = ...) (dataclass) Strict request for resizing one source-bound picture's visual extent.

wolfdocx.pictures

• author_picture(request: PictureRequest) -> PictureReport

  Replace one supported raster image and atomically publish the result.

• discover_picture_targets(source: str | Path, *, part: str | None = None) -> dict[str, Any]

  Inventory supported raster pictures in the document body and reachable headers/footers.

• load_picture_request(path: str | Path) -> PictureRequest

  Load one UTF-8 JSON picture authoring request.

• parse_picture_request(value: Any) -> PictureRequest

  Parse the strict JSON request for one atomic picture replacement operation.

• picture_structure_fingerprint(source: str | Path, *, paragraph: int, drawing: int = 1, part: str = 'word/document.xml') -> str | None

  Return the bounded picture structural fingerprint for request construction.

• PictureReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, target: dict[str, Any] | None, target_change_report: dict[str, Any] | None, non_target_parts_preserved: bool | None) (dataclass) Report of one picture replacement operation.
• PictureRequest(source: Path, source_sha256: str, destination: Path, structure_fingerprint_sha256: str, target: dict[str, Any], image_path: Path, image_sha256: str, expected_extent_cx: int | None = ..., expected_extent_cy: int | None = ...) (dataclass) Strict request for replacing one supported source-bound raster picture.
• PictureTarget (dataclass) One discovered supported inline or anchored raster picture target.

wolfdocx.pilot

• audit_pilot_packet(manifest: str | Path) -> PilotAuditReport
• scaffold_pilot_packet(packet_dir: str | Path, *, packet_id: str, template: str = 'template.docx', approved: str = 'approved.docx', failed: str = 'failed.docx') -> dict[str, Any]

• PilotAuditReport(manifest: str, manifest_sha256: str | None = ..., packet_id: str | None = ..., policy_sha256: str | None = ..., documents: list[dict[str, Any]] = ..., approved_diff: DiffReport | None = ..., failed_diff: DiffReport | None = ..., approved_evaluation: dict[str, Any] | None = ..., failed_evaluation: dict[str, Any] | None = ..., observed_failed_signals: list[dict[str, str | None]] = ..., missing_expected_signals: list[dict[str, str | None]] = ..., issues: list[str] = ..., execution_error: bool = ...) (dataclass)

wolfdocx.policy

• draft_gate_policy(baseline: str | Path, approved: str | Path, *, output: str | Path, draft_id: str, target_reference: str | Path | None = None) -> dict[str, Any]
• export_gate_policy_schema(output: str | Path) -> dict[str, Any]
• promote_gate_policy(draft: str | Path, *, output: str | Path, baseline_path: str, candidate_path: str, target_reference_path: str | None = None, allowed_changes: list[str], required_changes: list[str], active_content_mode: str, schema_mode: str, render_mode: str, content_assertions_file: str | Path | None = None, target_changes_file: str | Path | None = None, use_draft_target_changes: bool = False) -> dict[str, Any]

wolfdocx.policy_diff

• compare_gate_policies(before: str | Path, after: str | Path) -> PolicyComparisonReport

• PolicyChange (dataclass)
• PolicyComparisonError (exception)
• PolicyComparisonReport(before_name: str, after_name: str, before_sha256: str | None = ..., after_sha256: str | None = ..., changes: list[PolicyChange] = ..., issues: list[str] = ...) (dataclass)

wolfdocx.preflight

• resolve_preflight_capabilities(*, evidence_lanes: Sequence[str] | None = None, manifest_media_types: Sequence[str] | None = None, required_capabilities: Sequence[str] | None = None) -> list[str]

  Resolve the list of capability IDs required for this execution.

• run_flagship_preflight(*, manifest: Any = None, policies: Sequence[PreflightPolicyIdentity | Mapping[str, Any] | str] | None = None, environment: EnvironmentDescriptor | str | None = None, evidence_lanes: Sequence[str] | None = None, required_capabilities: Sequence[str] | None = None, workspace: Path | None = None, raise_on_rejection: bool = False, tool_overrides: Mapping[str, str] | None = None, disallowed_tools: Sequence[str] | None = None, disallowed_policies: Sequence[str] | None = None, unqualified_tools: Sequence[str] | None = None) -> PreflightReceipt

  Execute flagship preflight validation and emit a verified PreflightReceipt.

• verify_preflight_receipt(receipt: PreflightReceipt | Mapping[str, Any] | str | bytes, *, expected_environment: str | None = None) -> PreflightReceipt

  Verify and parse a PreflightReceipt strictly against schema and hashes.

• PreflightCapabilityIdentity (dataclass) Capability identity and evaluation status evaluated during preflight.
• PreflightConfigurationError (exception) Invalid preflight configuration or parameter.
• PreflightError (exception) Base error for preflight operations.
• PreflightPolicyIdentity (dataclass) Declared policy identity selected for preflight.
• PreflightProfileIdentity (dataclass) Confinement profile identity captured during preflight.
• PreflightReceipt (dataclass) Immutable, cryptographically bound receipt of flagship preflight.
• PreflightRejectionError (exception) Raised when preflight rejects due to unavailable/disallowed/unqualified tools.
• PreflightResolutionError (exception) Failure resolving policies, tools, or environments.
• PreflightSchemaError (exception) Schema validation error for preflight receipts.

wolfdocx.project

• accept_project(*, project: str | Path = PosixPath('.wolfdocx/project.json'), reason: str, evidence: str | None = None) -> ProjectAcceptReport
• check_project(candidate: str | Path, *, project: str | Path = PosixPath('.wolfdocx/project.json'), output_dir: str | None = None, open_review: bool = False, visual_review: bool = False, validator_project: str | Path = <absolute-path>, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', timeout_seconds: int = 120, browser_opener: BrowserOpener = <callable>) -> ProjectCheckReport
• initialize_project(baseline: str | Path, approved: str | Path, *, project_dir: str | Path = '.wolfdocx', project_id: str | None = None, allowed_changes: list[str] | None = None, required_changes: list[str] | None = None, approve_observed: bool = False, active_content_mode: str = 'preserve', schema_mode: str = 'disabled', render_mode: str = 'disabled', content_assertions_file: str | Path | None = None, use_draft_target_changes: bool = False, validator_project: str | Path = <absolute-path>, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', timeout_seconds: int = 120) -> ProjectInitReport
• load_project(project: str | Path = PosixPath('.wolfdocx/project.json')) -> ProjectDefinition
• project_status(project: str | Path = PosixPath('.wolfdocx/project.json')) -> ProjectStatusReport

• ProjectAcceptReport(passed: bool = ..., execution_error: bool = ..., project_id: str | None = ..., evidence_dir: str | None = ..., proposal: dict[str, Any] | None = ..., issues: list[str] = ...) (dataclass)
• ProjectCheckReport(passed: bool = ..., execution_error: bool = ..., project_id: str | None = ..., candidate_sha256: str | None = ..., evidence_dir: str | None = ..., review_path: str | None = ..., review_opened: bool = ..., warnings: list[str] = ..., issues: list[str] = ..., gate_report: dict[str, Any] | None = ...) (dataclass)
• ProjectContractError (exception)
• ProjectInitReport(passed: bool = ..., execution_error: bool = ..., project_id: str | None = ..., project_file: str | None = ..., policy: str | None = ..., evidence_dir: str | None = ..., observed_categories: list[str] = ..., allowed_categories: list[str] = ..., target_plan_status: str | None = ..., target_change_count: int = ..., warnings: list[str] = ..., issues: list[str] = ..., gate_report: dict[str, Any] | None = ...) (dataclass)
• ProjectStatusReport(ready: bool = ..., execution_error: bool = ..., project_id: str | None = ..., project_file: str | None = ..., policy: dict[str, Any] = ..., baseline: dict[str, Any] = ..., candidate: dict[str, Any] = ..., evidence: dict[str, Any] = ..., proposal: dict[str, Any] = ..., history: dict[str, Any] = ..., issues: list[str] = ...) (dataclass)

wolfdocx.properties

• author_custom_xml_storage(request: CustomXmlStorageRequest) -> CustomXmlStorageReport

  Add, replace, or remove document-owned Custom XML payload and properties parts.

• author_properties(request: PropertiesRequest) -> PropertiesReport

  Apply metadata and case-insensitive document-variable edits without field refresh.

• discover_custom_xml_storage(source: str | Path) -> dict[str, Any]

  Inspect Custom XML items owned by the document part, without exposing payloads.

• discover_property_targets(source: str | Path) -> dict[str, Any]

  Inspect source package document property parts, relationships, and metadata.

• load_custom_xml_storage_request(path: str | Path) -> CustomXmlStorageRequest

  Load a Custom XML storage lifecycle request from a UTF-8 JSON file.

• load_properties_request(path: str | Path) -> PropertiesRequest

  Load a document properties authoring request from a UTF-8 JSON file.

• parse_custom_xml_storage_request(value: Any) -> CustomXmlStorageRequest

  Parse a strict JSON-compatible Custom XML storage lifecycle request.

• parse_properties_request(value: Any) -> PropertiesRequest

  Parse and validate a structured document properties authoring request.

• read_custom_xml_part(source: str | Path, store_item_id: str) -> CustomXmlStoragePart | None

  Return one exact document-owned Custom XML item by its declared store identity.

• CustomPropertyEdit (dataclass) One requested modification to custom document properties.
• CustomPropertyRecord (dataclass) Internal model of one custom property inside custom.xml.
• CustomXmlStorageEdit (dataclass) One add, update, replacement, or removal of a document-owned Custom XML item.
• CustomXmlStoragePart (dataclass) One read-only Custom XML data item and its document-owned part topology.
• CustomXmlStorageReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, items: tuple[CustomXmlStoragePart, ...], changed_targets: tuple[dict[str, str], ...]) (dataclass) Result of a Custom XML storage lifecycle operation.
• CustomXmlStorageRequest(source: Path, destination: Path, source_sha256: str, edits: tuple[CustomXmlStorageEdit, ...]) (dataclass) Source-bound lifecycle request for document-owned Custom XML storage.
• PropertiesReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, core: dict[str, Any], custom: list[dict[str, Any]], changed_targets: list[dict[str, Any]], extended: dict[str, Any], variables: dict[str, str] = ..., measurement_unit: str | None = ...) (dataclass) Publication metadata and variables; application-level measurement units are unknown.
• PropertiesRequest(source: Path, source_sha256: str, destination: Path, core: dict[str, Any] | None = ..., custom: tuple[CustomPropertyEdit, ...] = ..., extended: dict[str, Any] | None = ..., variables: dict[str, str | None] | None = ..., measurement_unit: str | None = ...) (dataclass) Source-bound property and settings edits; appended fields default to unchanged.

wolfdocx.protection

• author_protection(request: ProtectionRequest | Mapping[str, Any]) -> ProtectionReport

  Execute source-bound document protection edit or removal atomically.

• discover_protection_targets(source: str | Path, *, part: str = 'word/settings.xml') -> dict[str, Any]

  Inventory document protection settings and editing exceptions without mutating.

• load_protection_request(path: str | Path) -> ProtectionRequest

  Load and strictly validate a protection request from JSON on disk.

• parse_protection_request(value: Any) -> ProtectionRequest

  Parse and strictly validate one JSON-compatible protection request.

• protection_structure_fingerprint(source: str | Path, *, part: str = 'word/settings.xml') -> str | None

  Return the structural fingerprint for settings.xml or documentProtection element.

• ProtectionReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., protection: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public report for one document protection authoring operation.
• ProtectionRequest(source: Path, destination: Path, source_sha256: str, structure_fingerprint_sha256: str, action: str = ..., edit: str | None = ..., enforcement: bool = ..., formatting: bool = ..., part: str = ..., permission_ranges: tuple[PermissionRange, ...] = ...) (dataclass) Strict request for modifying or removing document editing restrictions.

wolfdocx.quickstart

• run_quickstart(output_dir: str | Path) -> QuickstartReport

• QuickstartReport(passed: bool = ..., execution_error: bool = ..., output_name: str | None = ..., gate_passed: bool = ..., evidence_verified: bool = ..., archive_verified: bool = ..., baseline_sha256: str | None = ..., candidate_sha256: str | None = ..., policy_sha256: str | None = ..., evidence_manifest_sha256: str | None = ..., archive_sha256: str | None = ..., issues: list[str] = ...) (dataclass)

wolfdocx.regions

• author_region(request: RegionRequest) -> RegionReport

  Create, replace, or remove one section-bound header or footer region atomically and verify output.

• discover_region_targets(source: str | Path) -> dict[str, Any]

  Inventory section header and footer references and free variants without mutating.

• load_region_request(path: str | Path) -> RegionRequest

  Load and validate a region authoring request from JSON on disk.

• parse_region_request(value: Any) -> RegionRequest

  Parse and strictly validate a region authoring request.

• RegionParagraph (dataclass) One styled paragraph to be placed in a header or footer part.
• RegionReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, region: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ..., retained_unreferenced_parts: tuple[str, ...] | None = ..., link_to_previous: bool | None = ...) (dataclass) Public content-safe result of one region authoring operation.
• RegionRequest(source: Path, source_sha256: str, destination: Path, section: int, kind: str = ..., variant: str = ..., paragraphs: tuple[RegionParagraph, ...] = ..., action: str = ..., link_to_previous: bool | None = ...) (dataclass) Strict request for creating, replacing, or removing one section-bound header or footer region.

wolfdocx.render

• render_with_libreoffice(document: str | Path, *, output_dir: str | Path, executable: str = 'soffice', pdfinfo_executable: str = 'pdfinfo', timeout_seconds: int = 120, sandbox_mode: str = 'required', modes: RenderModes | None = None, save_options: RenderSaveOptions | None = None) -> RenderReport

  Render through LibreOffice; non-default native save policies explicitly refuse.

• RenderIssue (dataclass)
• RenderReport(input_path: str, output_path: str, engine: str = ..., engine_executable: str | None = ..., engine_version: str | None = ..., input_sha256: str = ..., output_sha256: str | None = ..., output_size: int | None = ..., page_count: int | None = ..., page_size: str | None = ..., duration_ms: int | None = ..., sandbox_mode: str = ..., sandboxed: bool = ..., sandbox_backend: str | None = ..., sandbox_profile_sha256: str | None = ..., resource_limits: dict[str, int] = ..., renderer_identity: RendererIdentity | None = ..., issues: list[RenderIssue] = ..., stdout: str = ..., stderr: str = ..., render_modes: dict[str, str] = ..., render_report: dict[str, Any] | None = ...) (dataclass)

wolfdocx.review

• author_review(request: ReviewRequest) -> ReviewReport
• decide_review(request: ReviewDecisionRequest) -> ReviewReport
• discover_review_revisions(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  List native revisions an exact part-qualified decision can name.

• discover_review_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  List source-bound paragraph targets supported by native tracked editing.

• load_review_decision_request(path: str | Path) -> ReviewDecisionRequest
• load_review_request(path: str | Path) -> ReviewRequest
• parse_review_decision_request(value: Any) -> ReviewDecisionRequest
• parse_review_request(value: Any) -> ReviewRequest

• ReviewDecisionRequest(source: Path, source_sha256: str, output: Path, action: str, revisions: tuple[ReviewRevisionRef, ...] = ..., author_filter: str | None = ...) (dataclass) One accept or reject decision over named revisions or one author's revisions.
• ReviewReport(status: str, code: str | None, source_sha256: str, output_sha256: str | None, revisions: list[dict[str, Any]], changed_targets: list[dict[str, Any]]) (dataclass)
• ReviewRequest(source: Path, source_sha256: str, output: Path, author: str, date: str, changes: tuple[ReviewChange, ...]) (dataclass)
• ReviewRevisionRef (dataclass) One part-qualified revision a decision names.

wolfdocx.rtf_export

• docx_to_rtf(source: str | Path, *, compact: bool = <sentinel>, wmf_copies: bool = <sentinel>, options: RtfSaveOptions | None = None) -> bytes

  Serialize a DOCX main document to a deterministic RTF 1.9 byte stream.

• export_rtf(source: str | Path, output: str | Path, *, compact: bool = <sentinel>, wmf_copies: bool = <sentinel>, options: RtfSaveOptions | None = None) -> RtfExportReport

  Convert ``source`` to a new RTF file without modifying or clobbering data.

• RtfExportError (exception) An RTF subset boundary, with a stable machine-readable refusal ``code``.
• RtfSaveOptions (dataclass) Immutable shared save policy for the existing portable RTF subset.

wolfdocx.run_text

• RunTextEditError (exception) An addressed edit refused before changing the session, identified by ``code``.

wolfdocx.sandbox_receipt

• assemble_sandbox_receipt(*, platform: str, policy_digest: str, profile_digest: str | None, worker: WorkerIdentity, runtime: RuntimeIdentity, tools: tuple[SandboxToolIdentity, ...], limits: EffectiveLimits, capabilities: ConfinementCapabilities, input_artifacts: tuple[ReceiptArtifact, ...], output_artifacts: tuple[ReceiptArtifact, ...], started_at: datetime, ended_at: datetime, duration_ms: int, failure: Failure | None, profile_class: str | None = None) -> SandboxRunReceipt

  Assemble one receipt, computing its identity digest internally.

• capture_linux_run(request: ContractRequest, *, policy: SandboxPolicy, output_dir: str | Path, input_dir: str | Path | None = None, timeout_seconds: float | None = None, staged_input_file: str | Path | None = None, publication_receipt: OutputPublicationReceipt | None = None) -> SandboxRunReceipt

  Run one profile-isolated Linux worker and return its receipt.

• capture_macos_development_run(request: ContractRequest, *, output_dir: str | Path, input_dir: str | Path | None = None, scratch_dir: str | Path | None = None, resource_paths: Sequence[str | Path] = (), env: Mapping[str, str] | None = None, timeout_seconds: float = 30.0, limits: WorkerLimits | None = None, staged_input_file: str | Path | None = None, publication_receipt: OutputPublicationReceipt | None = None) -> SandboxRunReceipt

  Run one profile-isolated macOS development worker and return its receipt.

• capture_supervised_run(request: ContractRequest, *, command: Sequence[str] | None = None, timeout_seconds: float = 30.0, limits: WorkerLimits | None = None) -> SandboxRunReceipt

  Run one supervised worker and return its identity and limits receipt.

• encode_sandbox_receipt(receipt: object) -> bytes

  Serialize one receipt as canonical, byte-stable JSON bytes.

• verify_sandbox_receipt(value: object, *, policy: SandboxPolicy | None = None) -> SandboxRunReceipt

  Verify one receipt strictly and return the parsed model.

• ConfinementCapabilities (dataclass) What the applied confinement allows, as the launcher constructed it.
• EffectiveLimits (dataclass) The effective limits one run was actually launched with.
• ReceiptArtifact (dataclass) One contracted artifact identity, by role and content digest.
• RuntimeIdentity (dataclass) The exact interpreter executable the launcher resolved, by digest.
• SandboxReceiptError (exception) A receipt failed strict structural, canonicality, or policy checks.
• SandboxRunReceipt (dataclass) One immutable, byte-stable record of an isolated worker run.
• SandboxToolIdentity (dataclass) One declared external tool by name and executable digest.
• WorkerIdentity (dataclass) The exact protocol worker a receipt binds to one run.

wolfdocx.sanitization

• load_docx_sanitization_request(path: str | Path) -> DocxSanitizationRequest

  Load one UTF-8 JSON request file with no path data in its result surface.

• parse_docx_sanitization_request(value: Any) -> DocxSanitizationRequest

  Parse the intentionally small public request schema without coercion.

• sanitize_docx(request: DocxSanitizationRequest) -> DocxSanitizationReport

  Remove the selected source-bound targets and publish one verified package.

• DocxSanitizationReport(operation: str, status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., removal: str | None = ..., removed: tuple[Mapping[str, Any], ...] = ..., retained: tuple[Mapping[str, Any], ...] = ..., counts: Mapping[str, int] = ..., verification: Mapping[str, Any] = ..., recovery: str | None = ...) (dataclass) The content-safe result of one sanitization request.
• DocxSanitizationRequest(source: Path, destination: Path, source_sha256: str, removals: tuple[str, ...]) (dataclass) One source-bound sanitization request.

wolfdocx.sanitization_inventory

• inspect_docx_sanitization(source: str | Path, *, source_sha256: str) -> DocxSanitizationInventoryReport

  Inventory every sanitization target of one source-bound DOCX package.

• load_docx_sanitization_inspect_request(path: str | Path) -> DocxSanitizationInspectRequest

  Load one UTF-8 JSON inventory request file with no path data in its result.

• parse_docx_sanitization_inspect_request(value: Any) -> DocxSanitizationInspectRequest

  Parse the intentionally small public inventory request without coercion.

• DocxSanitizationInspectRequest(source: Path, source_sha256: str) (dataclass) One source-bound inventory request: a package and the revision it names.
• DocxSanitizationInventoryReport(status: str, code: str | None, source_sha256: str, signature_present: bool = ..., parts: tuple[DocxSanitizationPart, ...] = ..., relationships: tuple[DocxSanitizationRelationship, ...] = ..., targets: tuple[DocxSanitizationTarget, ...] = ..., content_type_defaults: tuple[tuple[str, str], ...] = ..., content_type_overrides: tuple[tuple[str, str], ...] = ..., orphans: tuple[str, ...] = ..., counts: Mapping[str, int] = ..., recovery: str | None = ...) (dataclass) The content-safe inventory of one admitted source revision.
• DocxSanitizationPart (dataclass) One package part, with its content type, size, role, and exact reachability.
• DocxSanitizationRelationship (dataclass) One OPC relationship, described without echoing an external target.
• DocxSanitizationTarget (dataclass) One removal unit: what it covers, and whether this engine can remove it.

wolfdocx.schema

• validate_with_openxml_sdk(document: str | Path, *, project: str | Path = <absolute-path>, dotnet_executable: str = 'dotnet', target_file_format: str = 'microsoft365', max_errors: int = 100, timeout_seconds: int = 120, cache_directory: str | Path | None = None) -> SchemaValidationReport
• validator_lock_source_identity(project: str | Path) -> dict[str, object]

  Return the checked-in lock and project identity a sidecar must report.

• verify_validator_lock_identity(project: str | Path, reported: object | None, *, built_project: str | Path | None = None, dotnet_executable: str = 'dotnet') -> dict[str, object]

  Fail closed against the source lock and the executed sidecar's files.

• SchemaValidationReport(path: str, success: bool, valid: bool, validator: str = ..., validator_version: str | None = ..., target_file_format: str | None = ..., max_errors: int = ..., error_count: int = ..., error_limit_reached: bool = ..., duration_seconds: float = ..., errors: list[dict[str, object]] = ..., validator_lock_identity: dict[str, object] | None = ..., tool_error: str | None = ..., command: list[str] = ..., returncode: int | None = ..., stderr: str = ...) (dataclass)

wolfdocx.section_break

• author_section_break(request: SectionBreakRequest) -> SectionBreakReport

  Insert a source-bound body section break atomically and verification-checked.

• discover_section_break_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate body targets for section break authoring.

• load_section_break_request(path: str | Path) -> SectionBreakRequest

  Load and strictly validate one JSON section-break request from disk.

• parse_section_break_request(value: Any) -> SectionBreakRequest

  Parse and strictly validate a section break authoring request.

• section_break_anchor_fingerprint(source: str | Path, *, insert_after: int = 1, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural anchor fingerprint for one exact body index.

• SectionBreakReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., section_break: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., boundaries: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ..., native_section_break_render_supported: bool | None = ..., action: str = ..., link_to_previous: bool | None = ...) (dataclass) Content-safe public report for one section break authoring operation.
• SectionBreakRequest(source: Path, destination: Path, source_sha256: str, insert_after: int | None = ..., anchor_fingerprint_sha256: str = ..., break_type: str = ..., part: str = ..., action: str = ..., paragraph: int | None = ..., target: dict[str, Any] | None = ..., link_to_previous: bool | None = ...) (dataclass) Strict request for inserting, deleting, or updating a source-bound section break.
• SectionBreakTarget (dataclass) Discovered candidate target for section break authoring (insert, delete, or update).

wolfdocx.security

• decrypt_docx(request: DocxSecurityRequest) -> DocxSecurityReport

  Decrypt one admitted Agile container into its verified plaintext package.

• encrypt_docx(request: DocxSecurityRequest) -> DocxSecurityReport

  Encrypt one admitted DOCX into a standard Agile-encrypted CFB container.

• load_docx_security_request(path: str | Path) -> DocxSecurityRequest

  Load one UTF-8 JSON request file with no path data in its result surface.

• parse_docx_security_request(value: Any) -> DocxSecurityRequest

  Parse the intentionally small public request schema without coercion.

• DocxSecurityReport(operation: str, status: str, code: str | None, source_sha256: str, password_env: str, destination_sha256: str | None = ..., encryption_scheme: str | None = ..., recovery: str | None = ...) (dataclass) The content-safe result of one encryption or decryption request.
• DocxSecurityRequest(source: Path, destination: Path, source_sha256: str, password_env: str) (dataclass) One source-bound encryption or decryption request.

wolfdocx.shape_format

• author_shape_format(request: DrawingShapeFormatRequest) -> DrawingShapeFormatReport

  Publish one shape's supplied format components; retain all other bytes.

• discover_shape_format_targets(source: str | Path) -> dict[str, Any]

  Read supported fill, complete line ends and named effects without writing.

• load_shape_format_request(path: str | Path) -> DrawingShapeFormatRequest

  Load a UTF-8 JSON source-bound shape-format request.

• parse_shape_format_request(value: Any) -> DrawingShapeFormatRequest

  Parse the strict source-bound fill/line/effects request in OOXML units.

• DrawingShapeFormatReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, target: dict[str, Any], target_change_report: dict[str, Any] | None, non_target_parts_preserved: bool | None) (dataclass) Typed no-clobber publication result for a selected shape format change.
• DrawingShapeFormatRequest(source: Path, destination: Path, source_sha256: str, structure_fingerprint_sha256: str, target: dict[str, Any], format: dict[str, Any]) (dataclass) Source digest, drawing fingerprint, selector and partial format replacement.

wolfdocx.shapes

• author_canvas_child_delete(request: CanvasChildDeleteRequest) -> CanvasChildDeleteReport

  Delete exactly one supported child, retaining a nonempty canvas.

• author_shape_line(request: DrawingShapeLineRequest) -> DrawingShapeLineReport

  Create or replace one selected direct a:ln and atomically publish output.

• discover_canvas_child_delete_targets(source: str | Path) -> dict[str, Any]

  List supported canvas children with the existing drawing fingerprint.

• discover_shape_line_targets(source: str | Path) -> dict[str, Any]

  List source-bound supported shape line targets without writing.

• discover_shapes(source: str | Path) -> dict[str, Any]

  Discover supported shapes and their explicit direct line profiles.

• load_canvas_child_delete_request(path: str | Path) -> CanvasChildDeleteRequest

  Load a UTF-8 JSON canvas-child deletion request.

• load_shape_line_request(path: str | Path) -> DrawingShapeLineRequest

  Load a UTF-8 JSON drawing shape-line request.

• parse_canvas_child_delete_request(value: Any) -> CanvasChildDeleteRequest

  Parse a strict source-bound request; indexes are positive and one-based.

• parse_shape_line_request(value: Any) -> DrawingShapeLineRequest

  Parse a strict source-bound direct RGB/preset-dash shape-line request.

• CanvasChildDeleteReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, target: dict[str, Any], target_change_report: dict[str, Any] | None, non_target_parts_preserved: bool | None, rationale: str | None = ...) (dataclass) Atomic canvas deletion result, including an explicit refusal rationale.
• CanvasChildDeleteRequest(source: Path, destination: Path, source_sha256: str, structure_fingerprint_sha256: str, target: dict[str, Any]) (dataclass) Delete one canvas child selected by part/drawing/shape and source receipts.
• DrawingShapeLine (dataclass) One explicit direct ``a:ln`` profile supported by this public workflow.
• DrawingShapeLineReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, target: dict[str, Any] | None, target_change_report: dict[str, Any] | None, non_target_parts_preserved: bool | None) (dataclass) Result of a selected direct DrawingML shape-line mutation.
• DrawingShapeLineRequest(source: Path, destination: Path, source_sha256: str, structure_fingerprint_sha256: str, target: dict[str, Any], line: DrawingShapeLine) (dataclass) Strict source-bound request to create or replace one direct shape line.

wolfdocx.signature

• sign_evidence_bundle(bundle: str | Path, *, key: str | Path, output: str | Path, ssh_keygen_executable: str = 'ssh-keygen') -> EvidenceSignatureCreationReport
• verify_signed_evidence_bundle(bundle: str | Path, *, signature: str | Path | None, allowed_signers: str | Path | None, signer_identity: str | None, revocation_file: str | Path | None = None, expected_manifest_sha256: str | None = None, ssh_keygen_executable: str = 'ssh-keygen') -> SignedEvidenceVerificationReport

• EvidenceSignatureCreationReport(passed: bool = ..., execution_error: bool = ..., manifest_sha256: str | None = ..., bundle_kind: str | None = ..., signature_name: str | None = ..., signature_sha256: str | None = ..., issues: list[str] = ...) (dataclass)
• EvidenceSignatureVerificationReport(passed: bool = ..., execution_error: bool = ..., attempted: bool = ..., signer_identity: str | None = ..., signature_sha256: str | None = ..., allowed_signers_sha256: str | None = ..., revocation_file_sha256: str | None = ..., issues: list[str] = ...) (dataclass)
• SignedEvidenceVerificationReport(evidence: EvidenceVerificationReport, signature: EvidenceSignatureVerificationReport) (dataclass)

wolfdocx.smartart

• author_smartart_delete(request: SmartArtDeleteRequest) -> SmartArtReport

  Delete only the bound drawing and proven orphaned diagram dependencies.

• author_smartart_insert(request: SmartArtInsertRequest) -> SmartArtReport

  Append one inline linear diagram to an admitted paragraph, atomically.

• author_smartart_update(request: SmartArtUpdateRequest) -> SmartArtReport

  Edit/add/remove/reorder nodes or refresh using a complete ordered graph.

• discover_smartart(source: str | Path) -> dict[str, Any]

  Read source-bound targets and ordered editable nodes; list vendor refusals.

• load_smartart_request(path: str | Path) -> SmartArtInsertRequest | SmartArtUpdateRequest | SmartArtDeleteRequest

  Load a UTF-8 JSON request without writing or resolving external resources.

• parse_smartart_request(value: Any) -> SmartArtInsertRequest | SmartArtUpdateRequest | SmartArtDeleteRequest

  Strict JSON envelope: operation=insert/update/delete and dataclass fields.

• SmartArtDeleteRequest(source: Path, source_sha256: str, destination: Path, target: SmartArtTarget) (dataclass)
• SmartArtInsertRequest(source: Path, source_sha256: str, destination: Path, paragraph: int, width_emu: int, height_emu: int, nodes: tuple[SmartArtNodeSpec, ...], layout: str = ..., part: str = ...) (dataclass)
• SmartArtNodeSpec (dataclass) One plain-text node. Keep model_id unchanged when editing retained nodes.
• SmartArtReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: SmartArtTarget | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass)
• SmartArtTarget (dataclass) Exact whole drawing identity returned by discover_smartart.
• SmartArtUpdateRequest(source: Path, source_sha256: str, destination: Path, target: SmartArtTarget, width_emu: int, height_emu: int, nodes: tuple[SmartArtNodeSpec, ...], layout: str = ...) (dataclass) Complete replacement node list; omission deletes a semantic node.

wolfdocx.split

• split_document(source: str | Path, output_directory: str | Path, *, by: str = 'page', heading_level: int = 1, page_ranges: Sequence[tuple[int, int]] | None = None, context: ProcessorContext | None = None) -> SplitReport

  Publish consecutive documents split by ``page``, ``section`` or ``heading``.

• SplitError (exception) A typed content boundary refusal carrying a code and exact selector.
• SplitReport(status: str, code: str | None, source_sha256: str, by: str, parts: tuple[SplitPart, ...] = ..., text_preserved: bool | None = ..., target: str | None = ..., layout_boundaries: tuple[str, ...] = ..., warnings: tuple[RenderWarning, ...] = ..., substitutions: tuple[Mapping[str, Any], ...] = ..., load_report: LoadReport | None = ...) (dataclass) The existing split receipt plus immutable load and layout diagnostics.

wolfdocx.structural_recurrence

• build_structural_recurrence_receipt(source_receipt: str | Path, *, compared_artifact_ids: Sequence[str]) -> dict[str, object]

  Prove that reviewed generator artifacts recur on one declared structural branch.

• verify_structural_recurrence_receipt(payload: object) -> None

  Verify the receipt schema, identities, and explicit recurrence claims.

• write_structural_recurrence_receipt(source_receipt: str | Path, *, compared_artifact_ids: Sequence[str], output: str | Path) -> dict[str, object]

  Build and atomically write a non-overwriting canonical recurrence receipt.

• StructuralRecurrenceError (exception) Raised when a structural recurrence receipt is invalid or ambiguous.

wolfdocx.structural_signature

• derive_structural_signature(structural_evidence: Mapping[str, object]) -> dict[str, object]

  Derive a content-safe structural signature from public generator evidence.

• validate_declared_structural_signature(declared_signature: object, structural_evidence: Mapping[str, object]) -> dict[str, object]

  Reject a declared signature unless every algorithm and topology identity matches.

• validate_structural_signature(declared_signature: object) -> dict[str, object]

  Validate a caller-declared structural signature and its component identity.

• StructuralSignatureError (exception) Raised when a declared structural signature is unsafe or does not match.

wolfdocx.styles_authoring

• author_style(request: StyleRequest) -> StyleReport

  Execute source-bound style definition authoring atomically.

• discover_style_targets(source: str | Path, *, part: str = 'word/styles.xml') -> dict[str, Any]

  List source-bound style targets and structure fingerprints without writing.

• load_style_request(path: str | Path) -> StyleRequest

  Load and strictly validate a style authoring request from JSON on disk.

• parse_style_request(value: Any) -> StyleRequest

  Parse the strict JSON request for creating or updating one style definition.

• style_structure_fingerprint(source: str | Path, *, style_id: str | None = None, part: str = 'word/styles.xml') -> str | None

  Return the structural fingerprint for styles.xml or a specific style definition.

• StyleReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, style: dict[str, Any] | None = ..., changed_targets: list[dict[str, Any]] = ...) (dataclass) Content-safe public receipt for one atomic style authoring request.
• StyleRequest(source: Path, source_sha256: str, destination: Path, structure_fingerprint_sha256: str, action: str, style_id: str, type: str | None = ..., name: str | None = ..., based_on: str | None = ..., next: str | None = ..., run_properties: Mapping[str, Any] | None = ..., paragraph_properties: Mapping[str, Any] | None = ..., table_properties: Mapping[str, Any] | None = ..., cell_properties: Mapping[str, Any] | None = ..., row_properties: Mapping[str, Any] | None = ..., conditional_formatting: Sequence[dict[str, Any]] | None = ..., link: str | None = ..., clear_based_on: bool = ...) (dataclass) Strict request for creating or updating one named style definition.

wolfdocx.suite

• run_release_suite(manifest: str | Path, *, output_dir: str | Path, validator_project: str | Path = <absolute-path>, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', timeout_seconds: int = 120, jobs: int = 1, gate_runner: GateRunner = <callable>) -> ReleaseSuiteReport

• ReleaseSuiteReport(suite_id: str | None, manifest_path: str, manifest_sha256: str, jobs: int | None = ..., cases: list[SuiteCaseResult] = ..., issues: list[SuiteIssue] = ..., report_path: str | None = ...) (dataclass)
• SuiteCaseResult (dataclass)
• SuiteIssue (dataclass)

wolfdocx.supervisor

• supervise_worker(request: ContractRequest, *, command: Sequence[str] | None = None, timeout_seconds: float = 30.0, limits: WorkerLimits | None = None, cancel: WorkerCancel | None = None, cwd: str | Path | None = None, env: Mapping[str, str] | None = None) -> ContractResult

  Run one worker request under process-tree supervision.

• WorkerCancel (class) Thread-safe, idempotent cancellation handle for one supervised run.
• WorkerCancelledError (exception) The caller cancelled a supervised run before it completed.
• WorkerLimitError (exception) A supervisor limit configuration was structurally invalid.
• WorkerLimits (dataclass) Validated resource limits applied to a supervised worker tree.
• WorkerResourceLimitError (exception) A supervised worker breached one of its enforced resource limits.
• WorkerTerminationError (exception) A supervised process tree could not be fully terminated in bound.

wolfdocx.support

• export_support_bundle(*, project: str | Path = PosixPath('.wolfdocx/project.json'), output: str | Path, dotnet_executable: str = 'dotnet', soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', validator_project: str | Path = <absolute-path>) -> SupportExportReport
• verify_support_bundle(bundle: str | Path) -> SupportVerificationReport

• SupportExportReport(passed: bool = ..., execution_error: bool = ..., output_name: str | None = ..., archive_sha256: str | None = ..., archive_size_bytes: int | None = ..., manifest_sha256: str | None = ..., bundle_id: str | None = ..., file_count: int = ..., project_ready: bool | None = ..., doctor_ready: bool | None = ..., issues: list[str] = ...) (dataclass)
• SupportVerificationReport(passed: bool = ..., execution_error: bool = ..., archive_name: str | None = ..., archive_sha256: str | None = ..., manifest_sha256: str | None = ..., bundle_id: str | None = ..., files_checked: int = ..., bytes_checked: int = ..., issues: list[str] = ...) (dataclass)

wolfdocx.table_cell_properties

• author_table_cell_properties(request: TableCellPropertiesRequest) -> TableCellPropertiesReport

  Author direct formatting table cell properties on an exact body cell atomically.

• discover_table_cell_properties_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate table cell targets for authoring.

• load_table_cell_properties_request(path: str | Path) -> TableCellPropertiesRequest

  Load and strictly validate one JSON table-cell-properties request from disk.

• parse_table_cell_properties_request(value: Any) -> TableCellPropertiesRequest

  Parse and strictly validate a table cell properties authoring request.

• table_cell_properties_structure_fingerprint(source: str | Path, *, table: int, row: int, cell: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for one target table cell.

• TableCellPropertiesReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., properties: dict[str, Any] | None = ..., native_table_cell_properties_render_supported: bool | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a table cell properties authoring request.
• TableCellPropertiesRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, properties: Mapping[str, Any] | TableCellPropertiesSpec) (dataclass) One source-bound request to author direct formatting properties on an exact table cell.
• TableCellPropertiesSpec (dataclass)
• TableCellPropertiesTarget (dataclass) One discovered candidate table cell target for table cell properties authoring.

wolfdocx.table_column

• author_table_column(request: TableColumnRequest) -> TableColumnReport

  Insert, delete, or resize a source-bound table column atomically with full geometry synchronization.

• discover_table_column_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate table column targets for authoring.

• load_table_column_request(path: str | Path) -> TableColumnRequest

  Load and strictly validate one JSON table-column request from disk.

• parse_table_column_request(value: Any) -> TableColumnRequest

  Parse and strictly validate a table column authoring request.

• table_column_structure_fingerprint(source: str | Path, *, table: int, column: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for one target table column.

• TableColumnReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a table column authoring request.
• TableColumnRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, position: str | None = ..., width: int | None = ..., cell_texts: tuple[str, ...] | None = ..., action: str = ...) (dataclass) One source-bound request to insert, delete, or resize a table column.
• TableColumnTarget (dataclass) One discovered candidate table column that can serve as an authoring prototype or deletion target.

wolfdocx.table_delete

• author_table_delete(request: TableDeleteRequest) -> TableDeleteReport

  Delete an exact source-bound body table atomically, preserving surrounding structure.

• discover_table_delete_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate table targets for safe deletion.

• load_table_delete_request(path: str | Path) -> TableDeleteRequest

  Load and strictly validate one JSON table-delete request from disk.

• parse_table_delete_request(value: Any) -> TableDeleteRequest

  Parse and strictly validate a table delete authoring request.

• table_delete_structure_fingerprint(source: str | Path, *, table: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for one target body table.

• TableDeleteReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., deleted_table: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a table delete authoring request.
• TableDeleteRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str) (dataclass) One source-bound request to delete an exact body table.
• TableDeleteTarget (dataclass) One discovered candidate table target for deletion.

wolfdocx.table_insert

• author_table_insert(request: TableInsertRequest) -> TableInsertReport

  Insert a new rectangular table before or after a bound body paragraph atomically.

• discover_table_insert_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate body-paragraph anchors for table insertion.

• load_table_insert_request(path: str | Path) -> TableInsertRequest

  Load and strictly validate one JSON table-insert request from disk.

• parse_table_insert_request(value: Any) -> TableInsertRequest

  Parse and strictly validate a table insert authoring request.

• table_insert_structure_fingerprint(source: str | Path, *, paragraph: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for one exact paragraph.

• TableInsertReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., inserted_table: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a table insert authoring request.
• TableInsertRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, rows: tuple[tuple[str, ...], ...], grid_widths: tuple[int, ...], position: str = ..., style: str | None = ..., repeat_header: bool = ..., alignment: str | None = ..., shading: str | None = ...) (dataclass) One source-bound request to insert a rectangular table before or after a paragraph anchor.
• TableInsertTarget (dataclass) One candidate body-paragraph anchor for table insertion.

wolfdocx.table_merge

• author_table_merge(request: TableMergeRequest) -> TableMergeReport

  Execute a source-bound table cell merge or split authoring request atomically.

• discover_table_merge_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate table cell merge and split targets for authoring.

• load_table_merge_request(path: str | Path) -> TableMergeRequest

  Load and strictly validate one JSON table-merge request from disk.

• parse_table_merge_request(value: Any) -> TableMergeRequest

  Parse and strictly validate a table cell merge or split authoring request.

• table_merge_structure_fingerprint(source: str | Path, *, table: int, start_row: int, end_row: int, start_col: int, end_col: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for a target table rectangle.

• TableMergeReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a table merge or split authoring request.
• TableMergeRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, action: str = ...) (dataclass) One source-bound request to merge or split an explicit bounded table grid rectangle.
• TableMergeTarget (dataclass) One discovered candidate table rectangle for merge or split authoring.

wolfdocx.table_properties

• author_table_properties(request: TablePropertiesRequest) -> TablePropertiesReport

  Author direct formatting table properties on a source-bound document table atomically.

• discover_table_properties_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate table properties targets for authoring.

• load_table_properties_request(path: str | Path) -> TablePropertiesRequest

  Load and strictly validate one JSON table-properties request from disk.

• parse_table_properties_request(value: Any) -> TablePropertiesRequest

  Parse and strictly validate a table properties authoring request.

• table_properties_structure_fingerprint(source: str | Path, *, table: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for one target table.

• BorderSpec (dataclass)
• TableBordersSpec (dataclass)
• TableCellMarginsSpec (dataclass)
• TableCellSpacingSpec (dataclass)
• TableIndentSpec (dataclass)
• TableLayoutSpec (dataclass)
• TableLookSpec (dataclass)
• TablePropertiesReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., properties: dict[str, Any] | None = ..., native_table_properties_render_supported: bool | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a table properties authoring request.
• TablePropertiesRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, properties: Mapping[str, Any] | TablePropertiesSpec) (dataclass) One source-bound request to author direct formatting table properties on an exact table.
• TablePropertiesSpec (dataclass) Omitted fields stay unchanged; explicit ``None`` removes nullable direct properties.
• TablePropertiesTarget (dataclass) One discovered candidate table target for table properties authoring.
• TableShadingSpec (dataclass)
• TableWidthSpec (dataclass)

wolfdocx.table_row_properties

• author_table_row_properties(request: TableRowPropertiesRequest) -> TableRowPropertiesReport

  Author direct formatting table row properties on a source-bound document row atomically.

• discover_table_row_properties_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate table row properties targets for authoring.

• load_table_row_properties_request(path: str | Path) -> TableRowPropertiesRequest

  Load and strictly validate one JSON table-row-properties request from disk.

• parse_table_row_properties_request(value: Any) -> TableRowPropertiesRequest

  Parse and strictly validate a table row properties authoring request.

• table_row_properties_structure_fingerprint(source: str | Path, *, table: int, row: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for one target table row.

• RowHeightSpec (dataclass) Specification for table row height (w:trHeight).
• TableRowPropertiesReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., properties: dict[str, Any] | None = ..., native_table_row_properties_render_supported: bool | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a table row properties authoring request.
• TableRowPropertiesRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, properties: Mapping[str, Any] | TableRowPropertiesSpec) (dataclass) One source-bound request to author direct formatting table row properties on an exact row.
• TableRowPropertiesSpec (dataclass) Specification of row-level properties to author on an existing table row.
• TableRowPropertiesTarget (dataclass) One discovered candidate table row target for row properties authoring.

wolfdocx.table_structure

• author_table_row(request: TableRowRequest) -> TableRowReport

  Insert a source-bound styled table row before or after a bound prototype atomically.

• discover_table_row_targets(source: str | Path, *, part: str = 'word/document.xml') -> dict[str, Any]

  Inventory source-bound candidate table row targets for authoring.

• load_table_row_request(path: str | Path) -> TableRowRequest

  Load and strictly validate one JSON table-row request from disk.

• parse_table_row_request(value: Any) -> TableRowRequest

  Parse and strictly validate a table row authoring request.

• table_row_structure_fingerprint(source: str | Path, *, table: int, row: int, part: str = 'word/document.xml') -> str | None

  Return the source-bound structural fingerprint for one exact prototype row.

• TableRowReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a table row authoring request.
• TableRowRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str, position: str | None = ..., cell_texts: tuple[str, ...] | None = ..., repeat_header: bool | None = ..., cant_split: bool | None = ..., action: str = ...) (dataclass) One source-bound request to insert or delete a styled table row.
• TableRowTarget (dataclass) One discovered candidate table row that can serve as an authoring prototype.

wolfdocx.text_boxes

• author_text_box_delete(request: TextBoxDeleteRequest) -> TextBoxDeleteReport

  Delete one exact source-bound body text box atomically, preserving surrounding structure.

• author_text_box_insert(request: TextBoxInsertRequest) -> TextBoxInsertReport

  Insert one caller-provided page-positioned text box and atomically publish the result.

• discover_text_box_targets(source: str | Path, part: str | None = None) -> dict[str, Any]

  Inventory supported paragraph anchors for text box insertion.

• discover_text_boxes(source: str | Path) -> dict[str, Any]

  Inventory body and section-referenced header/footer text boxes.

• load_text_box_delete_request(path: str | Path) -> TextBoxDeleteRequest

  Load and strictly validate one JSON text-box delete request from disk.

• load_text_box_insert_request(path: str | Path) -> TextBoxInsertRequest

  Load one UTF-8 JSON text box insert authoring request.

• parse_text_box_delete_request(value: Any) -> TextBoxDeleteRequest

  Parse and strictly validate a text box delete authoring request.

• parse_text_box_insert_request(value: Any) -> TextBoxInsertRequest

  Parse the strict JSON request for inserting an anchored text box.

• text_box_structure_fingerprint(source: str | Path, *, paragraph: int, part: str = 'word/document.xml') -> str | None

  Return the bounded paragraph structural fingerprint for request construction.

• TextBoxAnchorSpec (dataclass) Position and layering specification for page-relative anchored text box insertion.
• TextBoxDeleteReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None = ..., target: dict[str, Any] | None = ..., deleted_text_box: dict[str, Any] | None = ..., target_change_report: dict[str, Any] | None = ..., non_target_parts_preserved: bool | None = ...) (dataclass) Content-safe public result for a text box delete authoring request.
• TextBoxDeleteRequest(source: Path, destination: Path, source_sha256: str, target: Mapping[str, Any], structure_fingerprint_sha256: str) (dataclass) One source-bound request to delete an exact body text box.
• TextBoxInsertReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, target: dict[str, Any] | None, target_change_report: dict[str, Any] | None, non_target_parts_preserved: bool | None) (dataclass) Report of one text box insertion operation.
• TextBoxInsertRequest(source: Path, source_sha256: str, destination: Path, paragraph: int, structure_fingerprint_sha256: str, text: str, extent_cx: int, extent_cy: int, anchor: TextBoxAnchorSpec, font_face: str | None = ..., font_size: int | None = ..., bold: bool | None = ..., italic: bool | None = ..., color: str | None = ..., fill: str | None = ..., border_color: str | None = ..., border_width_emu: int | None = ..., name: str | None = ..., part: str = ..., layout: TextBoxLayoutSpec = ..., representation: str = ..., word_art: WordArtSpec | None = ...) (dataclass) Strict request for inserting one bounded page-positioned text box into a paragraph.
• TextBoxTarget (dataclass) One discovered candidate paragraph anchor for text box insertion.

wolfdocx.variant_manifest

• parse_variant_manifest(value: object) -> dict[str, object]

  Parse one canonical caller declaration without accessing candidate artifacts.

• validate_variant_manifest(manifest: object, *, observed_inputs: Sequence[Mapping[str, object]], source_receipt: Mapping[str, object], structural_evidence: Mapping[str, object]) -> dict[str, object]

  Validate declared inputs and signature before any variant-specific execution.

• VariantManifestError (exception)

wolfdocx.variant_router

• route_variant(*, manifest: object, selection: object, observed_inputs: Sequence[Mapping[str, object]], source_receipt: Mapping[str, object], structural_evidence: Mapping[str, object], registry: Sequence[Mapping[str, object]]) -> dict[str, object]

  Validate prerequisites then select one exact declared compatible route; never dispatches.

• verify_variant_routing_receipt(receipt: object, *, manifest_receipt: Mapping[str, object], selection_receipt: Mapping[str, object], registry: Sequence[Mapping[str, object]]) -> dict[str, object]

  Fail closed unless an immutable routing receipt exactly binds its route.

• VariantRoutingError (exception)

wolfdocx.visual

• compare_libreoffice_renders(baseline: str | Path, candidate: str | Path, *, output_dir: str | Path, expectation: Expectation = 'equivalent', threshold: float = 0.0, dpi: int = 144, max_pages: int = 50, soffice_executable: str = 'soffice', pdftoppm_executable: str = 'pdftoppm', timeout_seconds: int = 120, sandbox_mode: str = 'required') -> VisualCompareReport

• ChangedRegion (dataclass)
• PageComparison (dataclass)
• VisualCompareReport(expectation: Expectation, threshold: float, dpi: int, output_dir: str, baseline_render: RenderReport, candidate_render: RenderReport, rasterizer_executable: str | None = ..., rasterizer_version: str | None = ..., rasterizer_sandboxed: bool = ..., rasterizer_sandbox_backend: str | None = ..., rasterizer_sandbox_profile_sha256: str | None = ..., page_comparisons: list[PageComparison] = ..., issues: list[VisualIssue] = ...) (dataclass)
• VisualIssue (dataclass)

wolfdocx.watermarks

• add_image_watermark(request: WatermarkRequest, watermark: ImageWatermark) -> WatermarkReport
• add_text_watermark(request: WatermarkRequest, watermark: TextWatermark) -> WatermarkReport
• discover_watermarks(source: str | Path, *, section: int | None = None) -> dict[str, Any]

  List the watermarks in each section's active default header story.

• load_image_watermark_request(path: str | Path) -> tuple[WatermarkRequest, ImageWatermark]
• load_text_watermark_request(path: str | Path) -> tuple[WatermarkRequest, TextWatermark]
• load_watermark_removal_request(path: str | Path) -> tuple[WatermarkRequest, str]
• parse_image_watermark_request(value: Any) -> tuple[WatermarkRequest, ImageWatermark]

  Parse ``{source, source_sha256, destination, section?, variant?, watermark}``.

• parse_text_watermark_request(value: Any) -> tuple[WatermarkRequest, TextWatermark]

  Parse ``{source, source_sha256, destination, section?, variant?, watermark}``.

• parse_watermark_removal_request(value: Any) -> tuple[WatermarkRequest, str]

  Parse ``{source, source_sha256, destination, section?, variant?, identifier}``.

• remove_watermark(request: WatermarkRequest, identifier: str) -> WatermarkReport

• ImageWatermark (dataclass)
• TextWatermark (dataclass)
• WatermarkReport(status: str, code: str | None, source_sha256: str, destination_sha256: str | None, watermark: dict[str, object] | None, non_target_parts_preserved: bool | None, header_inheritance_preserved: bool | None) (dataclass)
• WatermarkRequest(source: Path, source_sha256: str, destination: Path, section: int = ..., variant: str = ...) (dataclass)

wolfdocx.word_evidence

• validate_word_evidence(path: str | Path) -> WordEvidenceValidationReport

• WordEvidenceValidationReport(path: str, case_id: str | None = ..., issues: list[str] = ..., execution_error: bool = ...) (dataclass)

wolfdocx.worker_protocol

• decode_worker_request(value: object) -> ContractRequest

  Parse exactly one canonical worker request frame.

• decode_worker_terminal(value: object) -> WorkerTerminal

  Parse exactly one canonical worker terminal response frame.

• encode_worker_request(request: object) -> bytes

  Serialize one canonical, bounded worker request frame.

• encode_worker_terminal(terminal: object) -> bytes

  Serialize exactly one canonical, bounded terminal response frame.

• invoke_worker(request: ContractRequest, *, command: Sequence[str] | None = None, timeout_seconds: float = 30.0) -> ContractResult

  Run one explicit worker command with bounded stdin/stdout transport.

• read_worker_result(value: object, request: object) -> ContractResult

  Bind one terminal response to ``request`` or raise a safe typed failure.

• run_worker_stdio(stdin: IO[bytes], stdout: IO[bytes], *, handler: WorkerHandler) -> ExitStatus

  Serve exactly one request and emit exactly one terminal response.

• WorkerProtocolError (exception) A safe rejection of a malformed, oversized, or desynchronized frame.
• WorkerRemoteFailure (exception) A typed terminal failure returned by a remote worker.
• WorkerTerminal (dataclass) One versioned worker terminal response.
• WorkerTimeoutError (exception) A worker process exceeded the caller's explicit bounded deadline.
• WorkerTransportError (exception) A safe rejection of an unavailable or non-conforming worker process.