docforge-sdk 0.1.0__py3-none-any.whl

docforge_sdk/models/blobs.py

@@ -0,0 +1,25 @@
+# ====== Code Summary ======
+# Response model for the blobs resource. A blob endpoint streams raw bytes with a registered media
+# type rather than a JSON body, so BlobContent is an SDK-only wrapper (no matching OpenAPI schema)
+# pairing the fetched bytes with the server-declared mime type.
+
+# ====== Third-Party Library Imports ======
+from pydantic import BaseModel, Field
+
+
+class BlobContent(BaseModel):
+    """
+    A fetched blob's raw bytes plus its server-registered media type.
+
+    Attributes:
+        content (bytes): The raw blob bytes, verbatim.
+        mime_type (str): The media type the server registered for the blob.
+    """
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    content: bytes = Field(description="The raw blob bytes, verbatim.")
+    mime_type: str = Field(description="The media type the server registered for the blob.")
+
+
+__all__ = ["BlobContent"]

docforge_sdk/models/collections.py

@@ -0,0 +1,142 @@
+# ====== Code Summary ======
+# Request/response models for the collections resource, mirrored field-for-field from the DocForge
+# backend router models. The pipeline (ingest graph) and search blobs are opaque server-shaped JSON,
+# so they are typed as plain dicts rather than the engine's structured blob models.
+
+# ====== Standard Library Imports ======
+from datetime import datetime
+from typing import Any
+
+# ====== Third-Party Library Imports ======
+from pydantic import BaseModel, Field
+
+# ====== Local Project Imports ======
+from ._shared import FieldOrigin, FieldScope, FieldType
+
+
+class FieldSpec(BaseModel):
+    """
+    One metadata field of the collection's contract (declared OR generated).
+
+    Attributes:
+        field_name (str): Unique field name within the collection.
+        field_type (FieldType): Value type — drives validation and storage.
+        required (bool): Upload refused without it (user fields).
+        filterable (bool): Present in the Qdrant payload (lean vector).
+        lexical (bool): Gets a sparse BM25 named vector.
+        semantic (bool): Gets a dense named vector.
+        enum_values (list[str] | None): Allowed values when ``field_type`` is enum.
+        origin (FieldOrigin): user (declared at upload) or generated (metagen).
+        scope (FieldScope): document or chunk level value.
+    """
+
+    field_name: str = Field(description="Unique field name within the collection.")
+    field_type: FieldType = Field(description="Value type — drives validation and storage.")
+    required: bool = Field(default=False, description="Upload refused without it (user fields).")
+    filterable: bool = Field(default=False, description="Present in the Qdrant payload (lean).")
+    lexical: bool = Field(default=False, description="Gets a sparse BM25 named vector.")
+    semantic: bool = Field(default=False, description="Gets a dense named vector.")
+    enum_values: list[str] | None = Field(
+        default=None, description="Allowed values when field_type is enum."
+    )
+    origin: FieldOrigin = Field(
+        default=FieldOrigin.USER, description="user (declared at upload) or generated (metagen)."
+    )
+    scope: FieldScope = Field(
+        default=FieldScope.DOCUMENT, description="document or chunk level value."
+    )
+
+
+class CollectionModel(BaseModel):
+    """
+    One collection — the full contract the UI displays and edits.
+
+    Attributes:
+        id (str): The collection's UUID.
+        name (str): Unique human name.
+        supported_formats (list[str]): Accepted upload extensions (e.g. pdf).
+        max_file_size_bytes (int): Upload size ceiling, bytes.
+        needs_reindex (bool): True when a config change requires reindexing.
+        created_at (datetime | None): Creation timestamp.
+        pipeline (dict[str, Any]): The ingestion pipeline blob (the graph).
+        search (dict[str, Any]): The search pipeline graph blob ({} = the stock default).
+        fields (list[FieldSpec]): The metadata schema.
+    """
+
+    id: str = Field(description="The collection's UUID.")
+    name: str = Field(description="Unique human name.")
+    supported_formats: list[str] = Field(description="Accepted upload extensions (e.g. pdf).")
+    max_file_size_bytes: int = Field(description="Upload size ceiling, bytes.")
+    needs_reindex: bool = Field(description="True when a config change requires reindexing.")
+    created_at: datetime | None = Field(default=None, description="Creation timestamp.")
+    pipeline: dict[str, Any] = Field(description="The ingestion pipeline blob (the graph).")
+    search: dict[str, Any] = Field(
+        description="The search pipeline graph blob ({} = use the stock default)."
+    )
+    fields: list[FieldSpec] = Field(default_factory=list, description="The metadata schema.")
+
+
+class CreateCollectionRequest(BaseModel):
+    """
+    Create a collection from A to Z — contract, schema and (optionally) its pipeline.
+
+    Attributes:
+        name (str): Unique human name.
+        supported_formats (list[str]): Accepted upload extensions (e.g. pdf).
+        max_file_size_bytes (int): Upload size ceiling, bytes.
+        fields (list[FieldSpec]): The FULL schema, declared up front (vector space is fixed).
+        pipeline (dict[str, Any] | None): The pipeline blob; omitted → the product default.
+    """
+
+    name: str = Field(description="Unique human name.")
+    supported_formats: list[str] = Field(description="Accepted upload extensions (e.g. pdf).")
+    max_file_size_bytes: int = Field(description="Upload size ceiling, bytes.")
+    fields: list[FieldSpec] = Field(
+        default_factory=list,
+        description="The FULL schema, declared up front (vector space is fixed at creation).",
+    )
+    pipeline: dict[str, Any] | None = Field(
+        default=None,
+        description="The pipeline blob; omitted → the product default (all stages wired).",
+    )
+
+
+class UpdateCollectionRequest(BaseModel):
+    """
+    Patch any part of the collection — identity/limits, metadata schema, config blobs.
+
+    Attributes:
+        name (str | None): New unique name.
+        supported_formats (list[str] | None): New accepted upload extensions.
+        max_file_size_bytes (int | None): New size ceiling, bytes.
+        fields (list[FieldSpec] | None): The TARGET schema (diffed by field name).
+        pipeline (dict[str, Any] | None): New pipeline blob (validated before storage).
+        search (dict[str, Any] | None): New search graph blob ({} = stock default).
+        note (str | None): Version note shown in the history.
+    """
+
+    name: str | None = Field(default=None, description="New unique name.")
+    supported_formats: list[str] | None = Field(
+        default=None, description="New accepted upload extensions."
+    )
+    max_file_size_bytes: int | None = Field(default=None, description="New size ceiling, bytes.")
+    fields: list[FieldSpec] | None = Field(
+        default=None,
+        description="The TARGET schema (diffed by field name; omitted fields are removed).",
+    )
+    pipeline: dict[str, Any] | None = Field(
+        default=None, description="New pipeline blob (validated before being stored)."
+    )
+    search: dict[str, Any] | None = Field(
+        default=None,
+        description="New search pipeline graph blob ({} = stock default; validated before storage).",
+    )
+    note: str | None = Field(default=None, description="Version note shown in the history.")
+
+
+__all__ = [
+    "FieldSpec",
+    "CollectionModel",
+    "CreateCollectionRequest",
+    "UpdateCollectionRequest",
+]

docforge_sdk/models/documents.py

@@ -0,0 +1,49 @@
+# ====== Code Summary ======
+# Request/response models for the documents resource, mirrored field-for-field from the DocForge
+# backend router models: the async-admission response and the searchability toggle contract.
+
+# ====== Third-Party Library Imports ======
+from pydantic import BaseModel, Field
+
+
+class UploadAccepted(BaseModel):
+    """
+    Response for an accepted upload — the ingestion runs asynchronously.
+
+    Attributes:
+        document_id (str): The admitted document (poll its ingestion via the job).
+        job_id (str): The ingestion job driving status/progress ('' when duplicate).
+        duplicate (bool): True when this exact content+pipeline was already ingested — the EXISTING
+            document is returned and nothing is re-run.
+    """
+
+    document_id: str = Field(description="The admitted document's UUID.")
+    job_id: str = Field(description="The ingestion job's UUID ('' when duplicate).")
+    duplicate: bool = Field(default=False, description="Already ingested — nothing re-run.")
+
+
+class EnabledPatch(BaseModel):
+    """
+    The desired searchability state for a document (the reversible toggle).
+
+    Attributes:
+        enabled (bool): True to make it searchable, False to hide it from search.
+    """
+
+    enabled: bool = Field(description="True to make it searchable, False to hide it from search.")
+
+
+class DocumentEnabledResponse(BaseModel):
+    """
+    The state of a document after toggling its searchability.
+
+    Attributes:
+        document_id (str): The toggled document.
+        enabled (bool): Its new searchability state.
+    """
+
+    document_id: str = Field(description="The toggled document's UUID.")
+    enabled: bool = Field(description="The new searchability state.")
+
+
+__all__ = ["UploadAccepted", "EnabledPatch", "DocumentEnabledResponse"]

docforge_sdk/models/explorer.py

@@ -0,0 +1,238 @@
+# ====== Code Summary ======
+# Response/request models for the document explorer resource, mirrored field-for-field from the
+# DocForge backend router models: the catalogue list item, the per-document detail + resolved
+# metadata, a page's render reference, a chunk with its composition, and the chunk-toggle contract.
+
+# ====== Standard Library Imports ======
+from datetime import datetime
+from typing import Any
+
+# ====== Third-Party Library Imports ======
+from pydantic import BaseModel, Field
+
+# ====== Local Project Imports ======
+from ._shared import DocumentStatus, FieldOrigin, SourceKind
+
+
+class MetadataValue(BaseModel):
+    """
+    One resolved metadata value — the field name, the stored value and the origin that filled it.
+
+    Attributes:
+        field_name (str): The schema field this value fills.
+        value (Any): The stored JSON value (typed by the field).
+        origin (FieldOrigin): Who filled it: user / system / generated.
+    """
+
+    field_name: str = Field(description="The schema field this value fills.")
+    value: Any = Field(description="The stored JSON value (typed by the field).")
+    origin: FieldOrigin = Field(description="Who filled it: user / system / generated.")
+
+
+class DocumentListItem(BaseModel):
+    """
+    One row of a collection's document catalogue (the browse list).
+
+    Attributes:
+        id (str): The document's UUID.
+        filename (str): The uploaded file name.
+        format (str): The file extension (pdf, docx, …).
+        status (DocumentStatus): Ingestion lifecycle state.
+        page_count (int | None): Pages once parsed (None before).
+        file_size (int): Original size in bytes.
+        created_at (datetime | None): Admission timestamp.
+        title (str): Learned title ('' before parse).
+        language (str | None): Detected language (None before parse).
+        enabled (bool): Document-level searchability toggle.
+    """
+
+    id: str = Field(description="The document's UUID.")
+    filename: str = Field(description="The uploaded file name.")
+    format: str = Field(description="The file extension (pdf, docx, …).")
+    status: DocumentStatus = Field(description="Ingestion lifecycle state.")
+    page_count: int | None = Field(default=None, description="Pages once parsed (None before).")
+    file_size: int = Field(description="Original size in bytes.")
+    created_at: datetime | None = Field(default=None, description="Admission timestamp.")
+    title: str = Field(description="Learned title ('' before parse).")
+    language: str | None = Field(default=None, description="Detected language (None before parse).")
+    enabled: bool = Field(description="Document-level searchability toggle.")
+
+
+class DocumentDetail(BaseModel):
+    """
+    A document's full facts plus its resolved document-level metadata.
+
+    Attributes:
+        id (str): The document's UUID.
+        collection_id (str): Owning collection.
+        filename (str): The uploaded file name.
+        format (str): The file extension.
+        mime_type (str): The upload's declared content type.
+        file_size (int): Original size in bytes.
+        page_count (int | None): Pages once parsed.
+        language (str | None): Detected document language.
+        title (str): Learned title ('' before parse).
+        source_kind (SourceKind): Acquisition routing.
+        status (DocumentStatus): Ingestion lifecycle state.
+        source_hash (str): Content address of the original bytes (blob key).
+        pdf_blob_hash (str | None): Canonical PDF view blob (or None).
+        simhash (str | None): Near-duplicate signature (or None).
+        pipeline_version (str): Pipeline config identity the run used.
+        created_at (datetime | None): Admission timestamp.
+        enabled (bool): Document-level searchability toggle.
+        metadata (list[MetadataValue]): Document-level values (declared and generated).
+    """
+
+    id: str = Field(description="The document's UUID.")
+    collection_id: str = Field(description="Owning collection.")
+    filename: str = Field(description="The uploaded file name.")
+    format: str = Field(description="The file extension.")
+    mime_type: str = Field(description="The upload's declared content type.")
+    file_size: int = Field(description="Original size in bytes.")
+    page_count: int | None = Field(default=None, description="Pages once parsed.")
+    language: str | None = Field(default=None, description="Detected document language.")
+    title: str = Field(description="Learned title ('' before parse).")
+    source_kind: SourceKind = Field(description="Acquisition routing.")
+    status: DocumentStatus = Field(description="Ingestion lifecycle state.")
+    source_hash: str = Field(description="Content address of the original bytes (blob key).")
+    pdf_blob_hash: str | None = Field(
+        default=None, description="Canonical PDF view blob (or None)."
+    )
+    simhash: str | None = Field(default=None, description="Near-duplicate signature (or None).")
+    pipeline_version: str = Field(description="Pipeline config identity the run used.")
+    created_at: datetime | None = Field(default=None, description="Admission timestamp.")
+    enabled: bool = Field(description="Document-level searchability toggle.")
+    metadata: list[MetadataValue] = Field(
+        default_factory=list, description="Document-level values (declared and generated)."
+    )
+
+
+class PageInfo(BaseModel):
+    """
+    One page's geometry, routing and its render blob reference.
+
+    Attributes:
+        page_number (int): 0-based page index (first page = 0).
+        width (float | None): Page width in points (None if unknown).
+        height (float | None): Page height in points (None if unknown).
+        is_scanned (bool): Whether this page was routed as image-only (OCR/VLM).
+        language (str | None): Per-page detected language.
+        render_blob_hash (str | None): Blob of the rasterized page (None when render was off).
+    """
+
+    page_number: int = Field(description="0-based page index (first page = 0).")
+    width: float | None = Field(default=None, description="Page width in points (None if unknown).")
+    height: float | None = Field(
+        default=None, description="Page height in points (None if unknown)."
+    )
+    is_scanned: bool = Field(description="Whether this page was routed as image-only (OCR/VLM).")
+    language: str | None = Field(default=None, description="Per-page detected language.")
+    render_blob_hash: str | None = Field(
+        default=None, description="Blob of the rasterized page (None when render was off)."
+    )
+
+
+class ChunkInfo(BaseModel):
+    """
+    One retrieval chunk — enriched text, composition (block ids) and generated metadata.
+
+    Attributes:
+        id (str): The chunk UUID (doubles as the Qdrant point id).
+        chunk_index (int): Position of the chunk within the document.
+        text (str): The enriched, embedded text.
+        token_count (int): Token length of the enriched text.
+        is_indexed (bool): Whether the chunk is upserted into Qdrant.
+        role (str): Structural classification set by the pipeline.
+        enabled (bool): Effective searchability (override when set, else the role default).
+        strategy (str): The chunking strategy that produced it.
+        parent_id (str | None): Parent chunk (hierarchical chunking).
+        block_ids (list[str]): Composing IR block ids, in assembly order.
+        metadata (list[MetadataValue]): Per-chunk generated metadata values.
+    """
+
+    id: str = Field(description="The chunk UUID (doubles as the Qdrant point id).")
+    chunk_index: int = Field(description="Position of the chunk within the document.")
+    text: str = Field(description="The enriched, embedded text.")
+    token_count: int = Field(description="Token length of the enriched text.")
+    is_indexed: bool = Field(description="Whether the chunk is upserted into Qdrant.")
+    role: str = Field(description="Structural classification set by the pipeline.")
+    enabled: bool = Field(description="Effective searchability (override or role default).")
+    strategy: str = Field(description="The chunking strategy that produced it.")
+    parent_id: str | None = Field(default=None, description="Parent chunk (hierarchical chunking).")
+    block_ids: list[str] = Field(
+        default_factory=list, description="Composing IR block ids, in assembly (position) order."
+    )
+    metadata: list[MetadataValue] = Field(
+        default_factory=list, description="Per-chunk generated metadata values."
+    )
+
+
+class ChunkEnabledPatch(BaseModel):
+    """
+    The desired searchability state for one chunk (its enabled_override).
+
+    Attributes:
+        enabled (bool): True to make the chunk searchable, False to hide it.
+    """
+
+    enabled: bool = Field(description="True to make the chunk searchable, False to hide it.")
+
+
+class BulkChunkEnabledPatch(BaseModel):
+    """
+    Toggle several chunks' searchability to the same state in one call.
+
+    Attributes:
+        chunk_ids (list[str]): The chunks to toggle (at least one).
+        enabled (bool): The state to apply to every listed chunk.
+    """
+
+    chunk_ids: list[str] = Field(min_length=1, description="The chunks to toggle (at least one).")
+    enabled: bool = Field(description="The state to apply to every listed chunk.")
+
+
+class ChunkEnabledResult(BaseModel):
+    """
+    The outcome of toggling one chunk's searchability.
+
+    Attributes:
+        chunk_id (str): The toggled chunk.
+        enabled (bool): The recomputed EFFECTIVE state (override ?? role default).
+        reindex_required (bool): True when a never-embedded chunk was enabled — needs a re-embed.
+    """
+
+    chunk_id: str = Field(description="The toggled chunk's UUID.")
+    enabled: bool = Field(description="The recomputed effective searchability state.")
+    reindex_required: bool = Field(
+        description="True when a never-embedded chunk was enabled — needs a deferred re-embed."
+    )
+
+
+class BulkChunkEnabledResponse(BaseModel):
+    """
+    The per-chunk outcomes of a bulk toggle plus the ids that did not resolve to a chunk.
+
+    Attributes:
+        results (list[ChunkEnabledResult]): One outcome per KNOWN chunk.
+        not_found (list[str]): Requested ids with no matching chunk (skipped, not an error).
+    """
+
+    results: list[ChunkEnabledResult] = Field(
+        default_factory=list, description="One outcome per known chunk."
+    )
+    not_found: list[str] = Field(
+        default_factory=list, description="Requested ids with no matching chunk."
+    )
+
+
+__all__ = [
+    "MetadataValue",
+    "DocumentListItem",
+    "DocumentDetail",
+    "PageInfo",
+    "ChunkInfo",
+    "ChunkEnabledPatch",
+    "BulkChunkEnabledPatch",
+    "ChunkEnabledResult",
+    "BulkChunkEnabledResponse",
+]

docforge_sdk/models/health.py

@@ -0,0 +1,20 @@
+# ====== Code Summary ======
+# Response model for the health resource — the minimal liveness payload the bare-root /health probe
+# returns, mirrored field-for-field from the DocForge backend router model.
+
+# ====== Third-Party Library Imports ======
+from pydantic import BaseModel, Field
+
+
+class HealthStatus(BaseModel):
+    """
+    The public health probe payload.
+
+    Attributes:
+        status (str): Liveness marker — always ``"ok"`` when the app is serving.
+    """
+
+    status: str = Field(description="Liveness marker — always 'ok' when the app is serving.")
+
+
+__all__ = ["HealthStatus"]

docforge_sdk/models/ir.py

@@ -0,0 +1,139 @@
+# ====== Code Summary ======
+# Response models for the document IR view (GET /documents/{id}/ir), mirrored field-for-field from the
+# DocForge backend router models. Table cells and enrichment data are opaque server-shaped JSON, so
+# they are typed as ``Any`` rather than a structured grid model.
+
+# ====== Standard Library Imports ======
+from typing import Any
+
+# ====== Third-Party Library Imports ======
+from pydantic import BaseModel, Field
+
+# ====== Local Project Imports ======
+from ._shared import EnrichmentKind, EnrichmentStatus
+
+
+class IRBlock(BaseModel):
+    """
+    One RAW IR block — structure, position in reading order and native text.
+
+    Attributes:
+        id (str): Document-namespaced block id.
+        block_type (str): text / heading / list / table / figure / …
+        page (int): 0-based page the block sits on (first page = 0).
+        bbox (list[float]): Bounding box [x0, y0, x1, y1] in page coordinates.
+        reading_order (int): Global reading-order rank within the document.
+        column_index (int): Column the block belongs to (multi-column layouts).
+        parent_id (str | None): Parent block in the heading tree.
+        level (int | None): Heading level (None for non-headings).
+        text (str | None): Native extracted text (None for figures).
+        is_boilerplate (bool): Flagged repeated header/footer/watermark.
+        language (str | None): Per-block detected language.
+        confidence (float | None): Parser confidence (None if n/a).
+    """
+
+    id: str = Field(description="Document-namespaced block id.")
+    block_type: str = Field(description="text / heading / list / table / figure / …")
+    page: int = Field(description="0-based page the block sits on (first page = 0).")
+    bbox: list[float] = Field(description="Bounding box [x0, y0, x1, y1] in page coordinates.")
+    reading_order: int = Field(description="Global reading-order rank within the document.")
+    column_index: int = Field(description="Column the block belongs to (multi-column layouts).")
+    parent_id: str | None = Field(default=None, description="Parent block in the heading tree.")
+    level: int | None = Field(default=None, description="Heading level (None for non-headings).")
+    text: str | None = Field(default=None, description="Native extracted text (None for figures).")
+    is_boilerplate: bool = Field(description="Flagged repeated header/footer/watermark.")
+    language: str | None = Field(default=None, description="Per-block detected language.")
+    confidence: float | None = Field(default=None, description="Parser confidence (None if n/a).")
+
+
+class IRTable(BaseModel):
+    """
+    A TABLE block's parsed structure (1:1 with its block).
+
+    Attributes:
+        block_id (str): The TABLE block this detail belongs to.
+        n_rows (int): Row count of the grid.
+        n_cols (int): Column count of the grid.
+        has_header (bool): Whether the first row is a header.
+        cells (Any): Row-major 2D cell grid (opaque JSON).
+        linearized_md (str | None): Deterministic markdown rendering.
+    """
+
+    block_id: str = Field(description="The TABLE block this detail belongs to.")
+    n_rows: int = Field(description="Row count of the grid.")
+    n_cols: int = Field(description="Column count of the grid.")
+    has_header: bool = Field(description="Whether the first row is a header.")
+    cells: Any = Field(description="Row-major 2D cell grid (opaque JSON).")
+    linearized_md: str | None = Field(default=None, description="Deterministic markdown rendering.")
+
+
+class IRFigure(BaseModel):
+    """
+    A FIGURE block's parse-time facts (1:1 with its block).
+
+    Attributes:
+        block_id (str): The FIGURE block this detail belongs to.
+        crop_blob_hash (str | None): Blob of the cropped figure image (None if not stored).
+        caption_block_id (str | None): The associated caption block id.
+    """
+
+    block_id: str = Field(description="The FIGURE block this detail belongs to.")
+    crop_blob_hash: str | None = Field(
+        default=None, description="Blob of the cropped figure image (None if not stored)."
+    )
+    caption_block_id: str | None = Field(
+        default=None, description="The associated caption block id (proximity + numbering)."
+    )
+
+
+class IREnrichment(BaseModel):
+    """
+    One enrichment applied to a block (OCR/VLM/classify/chart_to_data/table_summary).
+
+    Attributes:
+        id (str): The enrichment UUID (use it to fetch the model-chain trace).
+        block_id (str): The enriched block.
+        kind (EnrichmentKind): What the enrichment produced.
+        text (str | None): OCR text / VLM description (None if data-only).
+        data (Any | None): Structured result (chart cells, classification).
+        status (EnrichmentStatus): ok / failed / skipped.
+    """
+
+    id: str = Field(description="The enrichment UUID (use it to fetch the model-chain trace).")
+    block_id: str = Field(description="The enriched block.")
+    kind: EnrichmentKind = Field(description="What the enrichment produced.")
+    text: str | None = Field(
+        default=None, description="OCR text / VLM description (None if data-only)."
+    )
+    data: Any | None = Field(
+        default=None, description="Structured result (chart cells, classification)."
+    )
+    status: EnrichmentStatus = Field(description="ok / failed / skipped.")
+
+
+class DocumentIRModel(BaseModel):
+    """
+    The full IR of a document — raw blocks, table/figure details and every enrichment.
+
+    Attributes:
+        blocks (list[IRBlock]): Raw blocks, reading order.
+        tables (list[IRTable]): Table detail rows.
+        figures (list[IRFigure]): Figure detail rows.
+        enrichments (list[IREnrichment]): Every block enrichment (OCR/VLM/…).
+    """
+
+    blocks: list[IRBlock] = Field(default_factory=list, description="Raw blocks, reading order.")
+    tables: list[IRTable] = Field(default_factory=list, description="Table detail rows.")
+    figures: list[IRFigure] = Field(default_factory=list, description="Figure detail rows.")
+    enrichments: list[IREnrichment] = Field(
+        default_factory=list, description="Every block enrichment (OCR/VLM/…)."
+    )
+
+
+__all__ = [
+    "IRBlock",
+    "IRTable",
+    "IRFigure",
+    "IREnrichment",
+    "DocumentIRModel",
+]