@anyformat/sdk 0.2.1 → 0.2.3

package/dist/index.d.ts

@@ -6,6 +6,13 @@ interface Auth {
      * @default 'header'
      */
     in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
     /**
      * Header or query parameter name.
      *
@@ -312,6 +319,37 @@ interface TDataShape {
 type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
 type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponse, TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & ([TData] extends [never] ? unknown : Omit<TData, 'url'>);
 
+/**
+ * ArithmeticCheck
+ */
+type ArithmeticCheck = {
+    /**
+     * Equals
+     *
+     * persistent_id whose value the result must equal.
+     */
+    equals: string;
+    /**
+     * Operands
+     *
+     * persistent_ids combined by `operator`.
+     */
+    operands: Array<string>;
+    /**
+     * Operator
+     */
+    operator?: 'sum' | 'subtract' | 'product';
+    /**
+     * Tolerance
+     *
+     * Absolute slack allowed around `equals`.
+     */
+    tolerance?: number;
+    /**
+     * Type
+     */
+    type: 'arithmetic';
+};
 /**
  * Block
  *
@@ -403,7 +441,7 @@ type BooleanField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Lookup
      */
@@ -414,6 +452,12 @@ type BooleanField = {
      * Field name. Used as the key in the extraction response.
      */
     name: string;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
 };
 /**
  * ClassificationResult
@@ -459,7 +503,7 @@ type ClassifyCategory = {
     /**
      * Name
      *
-     * Display name shown to the LLM.
+     * Display name shown to the LLM; classification and routing key off it, so it must be unique across categories.
      */
     name: string;
 };
@@ -484,10 +528,60 @@ type ClassifyNode = {
     /**
      * User Prompt
      *
-     * Optional prompt prefix for the classifier.
+     * Optional extra instructions inserted between the classifier's system prompt and the document text.
      */
     user_prompt?: string | null;
 };
+/**
+ * ComparisonCheck
+ */
+type ComparisonCheck = {
+    /**
+     * Left
+     *
+     * persistent_id of the left-hand field.
+     */
+    left: string;
+    /**
+     * Op
+     */
+    op: '==' | '!=' | '>' | '>=' | '<' | '<=';
+    /**
+     * Right
+     */
+    right: ({
+        source: 'field';
+    } & FieldOperand) | ({
+        source: 'literal';
+    } & LiteralOperand);
+    /**
+     * Type
+     */
+    type: 'comparison';
+};
+/**
+ * DateCheck
+ */
+type DateCheck = {
+    /**
+     * Earliest
+     */
+    earliest?: string | null;
+    /**
+     * Field
+     *
+     * persistent_id of the date field.
+     */
+    field: string;
+    /**
+     * Latest
+     */
+    latest?: string | null;
+    /**
+     * Type
+     */
+    type: 'date';
+};
 /**
  * DateField
  */
@@ -501,7 +595,7 @@ type DateField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Lookup
      */
@@ -512,6 +606,12 @@ type DateField = {
      * Field name. Used as the key in the extraction response.
      */
     name: string;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
 };
 /**
  * DatetimeField
@@ -526,7 +626,7 @@ type DatetimeField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Lookup
      */
@@ -537,6 +637,12 @@ type DatetimeField = {
      * Field name. Used as the key in the extraction response.
      */
     name: string;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
 };
 /**
  * Edge
@@ -573,7 +679,7 @@ type EnumField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Enum Options
      */
@@ -588,6 +694,12 @@ type EnumField = {
      * Field name. Used as the key in the extraction response.
      */
     name: string;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
 };
 /**
  * EnumOption
@@ -628,7 +740,7 @@ type Evidence = {
  */
 type ExtractNode = {
     /**
-     * Schema for the fields this node extracts. Required. The backend executor populates this from the ORM field tree before constructing the typed node; nothing else should be able to build an ExtractNode without it.
+     * Schema for the fields this node extracts. Required.
      */
     extraction_schema: ExtractionSchema;
     /**
@@ -640,7 +752,7 @@ type ExtractNode = {
     /**
      * Lookup File Uploads
      *
-     * Inline lookup-file content for the typed create call. The backend uploads each entry to S3 and stores the resulting URI in ``lookup_files``; this field is never persisted in GraphNode.config.
+     * Inline lookup-file content for the typed create call. Each entry is uploaded and the resulting URI is appended to ``lookup_files``; this field is create-input only.
      */
     lookup_file_uploads?: Array<LookupFileUpload>;
     /**
@@ -649,30 +761,18 @@ type ExtractNode = {
      * Smart-lookup reference document URIs persisted on the extract node.
      */
     lookup_files?: Array<string>;
+    /**
+     * Lookup Reasoning Effort
+     *
+     * Reasoning effort for the smart-lookup matcher (gpt-5 family): minimal | low | medium | high. None = model default. Higher effort improves match reliability on noisy join keys at higher latency/cost.
+     */
+    lookup_reasoning_effort?: 'minimal' | 'low' | 'medium' | 'high' | null;
     /**
      * Lookup Schema
      *
-     * Typed schema of fields the smart-lookup pass should produce. The *backend* derives this from the field tree (FieldWorkflowVersion rows whose source is SMART_LOOKUP) and attaches it to the node before the message hits the wire — the worker then reads it directly off the node, with no DB round-trip. Default empty: a node without smart-lookup fields carries an empty list.
-     */
-    lookup_schema?: Array<({
-        data_type: 'string';
-    } & StringField) | ({
-        data_type: 'integer';
-    } & IntegerField) | ({
-        data_type: 'float';
-    } & FloatField) | ({
-        data_type: 'boolean';
-    } & BooleanField) | ({
-        data_type: 'date';
-    } & DateField) | ({
-        data_type: 'datetime';
-    } & DatetimeField) | ({
-        data_type: 'enum';
-    } & EnumField) | ({
-        data_type: 'multi_select';
-    } & MultiSelectField) | ({
-        data_type: 'object';
-    } & ObjectField)>;
+     * Typed schema of fields the smart-lookup pass should produce. Derived server-side from the workflow's smart-lookup fields; default empty for nodes without any.
+     */
+    lookup_schema?: Array<StringField | IntegerField | FloatField | BooleanField | DateField | DatetimeField | EnumField | MultiSelectField | ObjectField>;
     /**
      * Lookup Suggestion
      *
@@ -681,14 +781,30 @@ type ExtractNode = {
     lookup_suggestion?: string | null;
     /**
      * Mode
+     *
+     * Extraction tier. 'standard' (default): single-pass extraction — the best balance for simple documents and layouts. 'agentic': multi-step extraction that maps every table to the schema and reasons across sections — for dense or cross-page tables; extra cost per page. 'max' (feature-gated): extracts table rows page by page with cross-page context tracking, then independently verifies row sums against document totals and re-extracts pages that don't reconcile — for multi-page invoices with complex row grouping. 'lite' (shown as 'Fast' in the app): standard extraction, faster and cheaper; quality may vary on complex layouts.
      */
-    mode?: 'standard' | 'agentic';
+    mode?: 'standard' | 'agentic' | 'max' | 'lite';
+    /**
+     * Page Sum Verification Enabled
+     *
+     * After row extraction, independently re-check each page's rows against document totals and re-extract pages that don't reconcile ('max' mode implies this).
+     */
+    page_sum_verification_enabled?: boolean;
+    /**
+     * Row Extractor Enabled
+     *
+     * Extract table rows page by page, carrying context across page breaks so rows stay in their group ('max' mode implies this).
+     */
+    row_extractor_enabled?: boolean;
     /**
      * Type
      */
     type: 'extract';
     /**
      * Use Images
+     *
+     * Standard/lite modes: send each PDF page's rendered image alongside its parsed text so the model can read layout the text missed — adds vision cost on every page. No effect in agentic/max modes or on non-PDF sources.
      */
     use_images?: boolean;
 };
@@ -697,7 +813,7 @@ type ExtractNode = {
  *
  * One extracted field's value, confidence, and supporting evidence.
  */
-type ExtractedField = {
+type ExtractedField$1 = {
     /**
      * Confidence
      *
@@ -744,8 +860,8 @@ type Extraction = {
      * Extracted fields keyed by field name. Same shape as the legacy top-level `extraction`.
      */
     fields: {
-        [key: string]: ExtractedField | Array<{
-            [key: string]: ExtractedField;
+        [key: string]: ExtractedField$1 | Array<{
+            [key: string]: ExtractedField$1;
         }>;
     };
     /**
@@ -764,16 +880,11 @@ type Extraction = {
 /**
  * ExtractionSchema
  *
- * Schema describing what an extract node produces. Modeled as a typed
- * object (not a bare ``list[AnyField]``) so metadata can be added later
- * (versioning, derived flags, output-shape hints) without another
- * wire-format break.
+ * Schema describing what an extract node produces.
  *
- * Every extraction schema must declare at least one field. The backend
- * executor populates this list from ``FieldWorkflowVersion`` rows
- * *before* constructing the typed ExtractNode; extract nodes without
- * any assigned fields are skipped at the executor layer rather than
- * sent to the worker with an empty schema.
+ * Modeled as a typed object (not a bare ``list[AnyField]``) so metadata
+ * can be added later (versioning, derived flags, output-shape hints)
+ * without another wire-format break. At least one field is required.
  */
 type ExtractionSchema = {
     /**
@@ -781,25 +892,7 @@ type ExtractionSchema = {
      *
      * Field definitions making up this extract's output.
      */
-    fields: Array<({
-        data_type: 'string';
-    } & StringField) | ({
-        data_type: 'integer';
-    } & IntegerField) | ({
-        data_type: 'float';
-    } & FloatField) | ({
-        data_type: 'boolean';
-    } & BooleanField) | ({
-        data_type: 'date';
-    } & DateField) | ({
-        data_type: 'datetime';
-    } & DatetimeField) | ({
-        data_type: 'enum';
-    } & EnumField) | ({
-        data_type: 'multi_select';
-    } & MultiSelectField) | ({
-        data_type: 'object';
-    } & ObjectField)>;
+    fields: Array<StringField | IntegerField | FloatField | BooleanField | DateField | DatetimeField | EnumField | MultiSelectField | ObjectField>;
 };
 /**
  * FilePages
@@ -839,7 +932,7 @@ type FloatField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Lookup
      */
@@ -850,6 +943,12 @@ type FloatField = {
      * Field name. Used as the key in the extraction response.
      */
     name: string;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
 };
 /**
  * Hyperlink
@@ -883,7 +982,7 @@ type IntegerField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Lookup
      */
@@ -894,6 +993,12 @@ type IntegerField = {
      * Field name. Used as the key in the extraction response.
      */
     name: string;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
 };
 /**
  * LookupFileUpload
@@ -901,9 +1006,9 @@ type IntegerField = {
  * Inline lookup-file content carried on the typed create call.
  *
  * The backend reads ``filename`` + ``content`` (base64-encoded bytes),
- * uploads the file to S3 during workflow create, and stores the resulting
- * URI in ``ExtractNode.lookup_files``. This field is stripped from the
- * persisted ``GraphNode.config`` — it is create-input only.
+ * uploads the file, and stores the resulting URI in
+ * ``ExtractNode.lookup_files``. Create-input only — not persisted on
+ * the node after upload.
  */
 type LookupFileUpload = {
     /**
@@ -930,7 +1035,7 @@ type MultiSelectField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Enum Options
      */
@@ -945,6 +1050,12 @@ type MultiSelectField = {
      * Field name. Used as the key in the extraction response.
      */
     name: string;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
 };
 /**
  * ObjectField
@@ -959,7 +1070,7 @@ type ObjectField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Lookup
      */
@@ -972,35 +1083,66 @@ type ObjectField = {
     name: string;
     /**
      * Nested Fields
+     *
+     * Child fields of this object. Only one level of nesting is supported — an object field's children must be non-object types.
      */
-    nested_fields: Array<({
-        data_type: 'string';
-    } & StringField) | ({
-        data_type: 'integer';
-    } & IntegerField) | ({
-        data_type: 'float';
-    } & FloatField) | ({
-        data_type: 'boolean';
-    } & BooleanField) | ({
-        data_type: 'date';
-    } & DateField) | ({
-        data_type: 'datetime';
-    } & DatetimeField) | ({
-        data_type: 'enum';
-    } & EnumField) | ({
-        data_type: 'multi_select';
-    } & MultiSelectField) | ({
-        data_type: 'object';
-    } & ObjectField)>;
+    nested_fields: Array<StringField | IntegerField | FloatField | BooleanField | DateField | DatetimeField | EnumField | MultiSelectField>;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
+};
+/**
+ * OneOfCheck
+ */
+type OneOfCheck = {
+    /**
+     * Allowed
+     */
+    allowed: Array<string>;
+    /**
+     * Case Sensitive
+     */
+    case_sensitive?: boolean;
+    /**
+     * Field
+     */
+    field: string;
+    /**
+     * Type
+     */
+    type: 'one_of';
 };
 /**
  * ParseNode
  */
 type ParseNode = {
+    /**
+     * Cache
+     *
+     * Reuse parsed output when the same file was already parsed with the same mode and settings — a hit skips the whole parse. Disable to force a fresh parse.
+     */
+    cache?: boolean;
+    /**
+     * Effort
+     *
+     * Agentic mode: quality/cost preset. 'low' = several times cheaper but more errors on dense or low-contrast tables, 'mid' (default) = balanced, 'accurate' = highest fidelity. (Distinct from lite `ocr_effort`.)
+     */
+    effort?: 'low' | 'mid' | 'accurate';
     /**
      * Figure Enhancement
+     *
+     * Standard mode: extract structured data from charts and images — extra processing per figure. Ignored in agentic (figures are already handled) and in lite (use `figures` instead).
      */
     figure_enhancement?: boolean;
+    /**
+     * Figures
+     *
+     * Lite mode: the correction pass reads data points off charts/figures and reconstructs them as HTML tables (extra work on figure pages; needs skip_routing_review=False).
+     */
+    figures?: boolean;
     /**
      * Id
      *
@@ -1009,14 +1151,46 @@ type ParseNode = {
     id: string;
     /**
      * Mode
+     *
+     * Parse tier. 'standard' (default): page-by-page parsing with reading-order correction — the best quality/speed balance for most documents and tables. 'agentic': adaptive parsing that works hardest on dense tables (50+ rows, many columns) — highest fidelity on complex documents; extra cost per page. 'lite' (shown as 'Fast' in the app): OCR-first tier, fastest and cheapest — accurate OCR by default; set skip_routing_review=False to add a correction pass when reading order, figures, or text formatting matter.
+     */
+    mode?: 'standard' | 'agentic' | 'lite';
+    /**
+     * Ocr Effort
+     *
+     * Lite mode: 'high' (default) = the strongest OCR — best accuracy on complex layouts, tables, and handwriting, and usually all a document needs. 'medium' = faster and cheaper, for clean digital documents. (Distinct from agentic `effort`.)
      */
-    mode?: 'standard' | 'agentic';
+    ocr_effort?: 'medium' | 'high';
     /**
      * Prompt Hint
      *
-     * Free-form hint shown to the parse model to bias output.
+     * Free-form hint that biases the parse output. In lite mode it guides the correction pass, so it requires skip_routing_review=False.
      */
     prompt_hint?: string | null;
+    /**
+     * Region
+     *
+     * Lite mode: OCR data-residency. 'eu' keeps processing in-region; 'global' uses the hosted endpoint. Feature-flagged.
+     */
+    region?: 'eu' | 'global';
+    /**
+     * Routing Effort
+     *
+     * Lite mode: effort of the correction pass's reading-order analysis — its dominant latency knob (None = the highest). Lower it to cut latency on simple layouts.
+     */
+    routing_effort?: 'minimal' | 'low' | 'medium' | 'high' | null;
+    /**
+     * Skip Routing Review
+     *
+     * Lite mode: emit the OCR output as-is (the default — fastest and cheapest). Set False to add a correction pass that fixes reading order and OCR errors and rebuilds broken tables; while True, figures/text_formatting/routing_effort/prompt_hint are inert.
+     */
+    skip_routing_review?: boolean;
+    /**
+     * Text Formatting
+     *
+     * Lite mode: the correction pass restores inline styling (bold/italic/superscript), code, and LaTeX math in text blocks (needs skip_routing_review=False).
+     */
+    text_formatting?: boolean;
     /**
      * Type
      */
@@ -1059,6 +1233,61 @@ type ParseResult = {
      */
     text?: string | null;
 };
+/**
+ * RangeCheck
+ */
+type RangeCheck = {
+    /**
+     * Field
+     *
+     * persistent_id of the bounded numeric field.
+     */
+    field: string;
+    /**
+     * Max
+     */
+    max?: number | null;
+    /**
+     * Min
+     */
+    min?: number | null;
+    /**
+     * Type
+     */
+    type: 'range';
+};
+/**
+ * RegexCheck
+ */
+type RegexCheck = {
+    /**
+     * Field
+     */
+    field: string;
+    /**
+     * Pattern
+     *
+     * Evaluated with google-re2 (linear time); never stdlib re.
+     */
+    pattern: string;
+    /**
+     * Type
+     */
+    type: 'regex';
+};
+/**
+ * RequiredCheck
+ */
+type RequiredCheck = {
+    /**
+     * Field
+     */
+    field: string;
+    /**
+     * Type
+     */
+    type: 'required';
+};
 /**
  * ResultsResponse
  *
@@ -1088,8 +1317,8 @@ type ResultsResponse = {
      * @deprecated
      */
     extraction?: {
-        [key: string]: ExtractedField | Array<{
-            [key: string]: ExtractedField;
+        [key: string]: ExtractedField$1 | Array<{
+            [key: string]: ExtractedField$1;
         }>;
     } | null;
     /**
@@ -1206,6 +1435,8 @@ type SplitterRule = {
     name: string;
     /**
      * Partition Key
+     *
+     * Field that further partitions this category into separate sub-documents (e.g. invoice_number): each distinct value becomes its own split, extracted independently. Empty = routing-only, the whole category flows on as one document.
      */
     partition_key?: string;
 };
@@ -1222,7 +1453,7 @@ type StringField = {
      *
      * Free-form description shown to the extraction model.
      */
-    description: string;
+    description?: string;
     /**
      * Lookup
      */
@@ -1233,11 +1464,25 @@ type StringField = {
      * Field name. Used as the key in the extraction response.
      */
     name: string;
+    /**
+     * Persistent Id
+     *
+     * Server-assigned stable field identity (UUID), emitted by GET /definition/. Echo it back on updates — including across renames — to keep quality metrics, ground-truth links and analytics attached to the field. Matching is scoped to the field's nesting level in the immediately-prior version; an id that matches nothing at its level, appears on more than one field, or is sent at workflow creation is rejected with 400. Omit for new fields; when omitted on an update, the server matches the field to the prior version by name.
+     */
+    persistent_id?: string | null;
 };
 /**
  * ValidateNode
  */
 type ValidateNode = {
+    /**
+     * Field Index
+     *
+     * Executor-injected at run time (persistent_id → field name); never set by callers or persisted.
+     */
+    field_index?: {
+        [key: string]: string;
+    } | null;
     /**
      * Id
      *
@@ -1257,26 +1502,54 @@ type ValidateNode = {
  * ValidationRule
  */
 type ValidationRule = {
+    /**
+     * Check
+     *
+     * Structured deterministic check. Required when kind == 'deterministic'.
+     */
+    check?: ({
+        type: 'range';
+    } & RangeCheck) | ({
+        type: 'date';
+    } & DateCheck) | ({
+        type: 'arithmetic';
+    } & ArithmeticCheck) | ({
+        type: 'comparison';
+    } & ComparisonCheck) | ({
+        type: 'one_of';
+    } & OneOfCheck) | ({
+        type: 'regex';
+    } & RegexCheck) | ({
+        type: 'required';
+    } & RequiredCheck) | null;
     /**
      * Description
      *
-     * Natural-language description shown to the validation model.
+     * Natural-language description sent to the LLM. Required when kind == 'ai'.
      */
-    description: string;
+    description?: string | null;
     /**
      * Id
      *
-     * Stable rule id; round-trips through ValidationResult.rule_id.
+     * Stable rule id; round-trips through validation results.
      */
     id: string;
+    /**
+     * Kind
+     *
+     * 'deterministic' = a structured check run in code — instant, free, reproducible; 'ai' = a model judges the rule description against the extraction. Prefer deterministic whenever the condition is exact and testable.
+     */
+    kind?: 'ai' | 'deterministic';
     /**
      * Name
      *
-     * Optional human-readable rule name shown on the rule card in the Studio. Stored verbatim on the GraphNode config and surfaced back through the config endpoint so renames round-trip.
+     * Optional human-readable rule name. Round-trips through the config endpoint so renames are preserved.
      */
     name?: string | null;
     /**
      * Severity
+     *
+     * How a failed rule is labelled in results. Display-level only — it never blocks the run.
      */
     severity?: 'error' | 'warning';
     /**
@@ -1289,7 +1562,12 @@ type ValidationRule = {
 /**
  * WorkflowCreateRequest
  *
- * Public-surface workflow create body — typed graph of parse / classify / splitter / extract nodes.
+ * Public-surface workflow create body — typed graph of parse / classify / splitter / extract / validate nodes.
+ *
+ * A ``validate`` node carries ``rules``; each rule is either AI-evaluated
+ * (``kind="ai"`` + a natural-language ``description``) or deterministic
+ * (``kind="deterministic"`` + a structured ``check``, evaluated in pure
+ * Python with no model call).
  *
  * Defined as a thin subclass so the FastAPI-generated OpenAPI components
  * entry is named ``WorkflowCreateRequest`` (FastAPI uses the model's
@@ -1312,62 +1590,160 @@ type WorkflowCreateRequest = {
     /**
      * Nodes
      */
-    nodes: Array<({
-        type: 'parse';
-    } & ParseNode) | ({
-        type: 'classify';
-    } & ClassifyNode) | ({
-        type: 'splitter';
-    } & SplitterNode) | ({
-        type: 'extract';
-    } & ExtractNode) | ({
-        type: 'validate';
-    } & ValidateNode)>;
+    nodes: Array<ParseNode | ClassifyNode | SplitterNode | ExtractNode | ValidateNode>;
 };
+/**
+ * _FieldOperand
+ */
+type FieldOperand = {
+    /**
+     * Field
+     *
+     * persistent_id of the compared field.
+     */
+    field: string;
+    /**
+     * Source
+     */
+    source: 'field';
+};
+/**
+ * _LiteralOperand
+ */
+type LiteralOperand = {
+    /**
+     * Source
+     */
+    source: 'literal';
+    /**
+     * Value
+     */
+    value: number | string | boolean;
+};
+
+/**
+ * Typed view over the parse node's output. Returned by `Result.parse` — readers
+ * use it for `.markdown`, `.text`, `.blocks`, `.parseConfidence`, and
+ * `.layoutConfidence` without having to walk `result.raw.parse`.
+ *
+ * No `.draw()` here: rasterising pages requires PDF rendering (pdfium); the
+ * Python SDK ships that, the TS SDK does not.
+ */
+declare class ParseView {
+    private readonly parse;
+    /** @internal */
+    constructor(parse: ParseResult);
+    get markdown(): string | null;
+    get text(): string | null;
+    get blocks(): Block[];
+    /**
+     * Document-level confidence (0-100) in the parsed content. May be `null` for
+     * some parse modes — fall back to `layoutConfidence`.
+     */
+    get parseConfidence(): number | null;
+    /**
+     * Document-level confidence (0-100) in the page layout (block positions).
+     * `null` when not available.
+     */
+    get layoutConfidence(): number | null;
+}
 
+/**
+ * One extracted field — generic over the value type so callers get real
+ * types at the access site (`result.field<number>("total").value` is
+ * `number | null`, not `unknown`). Wire shape identical to the codegen type.
+ */
+type ExtractedField<T = unknown> = Omit<ExtractedField$1, "value" | "value_override"> & {
+    value: T | null;
+    value_override?: T | null;
+};
 /** Typed wrapper over a completed run's results. */
 declare class Result {
     readonly raw: ResultsResponse;
+    private _parse;
     constructor(raw: ResultsResponse);
     get collectionId(): string;
     get extractions(): Extraction[];
+    /**
+     * Typed view over the parse node's output, or `null` when the workflow has
+     * no parse node. Cached so repeated access doesn't re-wrap.
+     */
+    get parse(): ParseView | null;
     /**
      * Convenience accessor for a top-level scalar field on the first
      * extraction (linear workflows). Returns `undefined` for missing fields
      * or list-valued fields — read `extractions` directly for those.
+     *
+     * Parameterise with the declared schema type to type `.value`:
+     * `result.field<number>("total").value` is `number | null`.
      */
-    field(name: string): ExtractedField | undefined;
+    field<T = unknown>(name: string): ExtractedField<T> | undefined;
 }
 
 interface WaitOptions {
-    /** Overall budget before giving up. Default 120s. */
+    /** Overall budget before giving up. Default 300 000 ms (300s). */
     timeoutMs?: number;
-    /** Delay between result polls. Default 2s. */
+    /** Delay between result polls. Default 3 000 ms (3s). */
     pollMs?: number;
 }
 /**
- * A pending run. Lazily creates the workflow, submits the document, and
- * polls for results when `wait()` is awaited.
+ * A submitted run. `wait()` polls for completion. Created eagerly by
+ * `Workflow.run()` — the workflow + file submission have already happened
+ * by the time you hold a `Run`.
  */
 declare class Run {
     private readonly client;
-    private readonly request;
-    private readonly file;
-    private readonly text;
-    private workflowId;
-    private collectionId;
-    constructor(client: Client, request: WorkflowCreateRequest, file: Blob | File | null, text: string | null);
-    /**
-     * Create the workflow and submit the document — exactly once per `Run`.
-     * Memoized so that retrying `wait()` after an `SDKTimeout` resumes polling
-     * the in-flight run instead of creating a duplicate workflow + submission.
-     */
-    private submit;
+    readonly workflowId: string;
+    readonly id: string;
+    /** @internal */
+    constructor(client: Client, workflowId: string, id: string);
     wait(opts?: WaitOptions): Promise<Result>;
 }
 
+/**
+ * A document staged in a workflow but not yet run. Returned by
+ * `Workflow.upload()`. Call `run()` to start extraction — uploading alone
+ * spends no credits.
+ */
+declare class Upload {
+    private readonly client;
+    readonly workflowId: string;
+    readonly collectionId: string;
+    readonly fileId: string | null;
+    /** @internal */
+    constructor(client: Client, workflowId: string, collectionId: string, fileId: string | null);
+    /** Trigger extraction on the staged file and return a pending `Run`. */
+    run(): Promise<Run>;
+}
+
+/**
+ * A persisted workflow on the server. Returned by `WorkflowBuilder.create()`.
+ * `run(file)` submits a document and returns a `Run` you can `.wait()` on.
+ * `upload(file)` stages a document without running it; call `.run()` on the
+ * returned `Upload` to extract.
+ */
+declare class Workflow {
+    private readonly client;
+    readonly id: string;
+    readonly name: string;
+    /** @internal */
+    constructor(client: Client, id: string, name: string);
+    /** Submit a document against this workflow and return a pending `Run`. */
+    run(file?: File | null): Promise<Run>;
+    /**
+     * Stage a document in this workflow WITHOUT running it (no credits spent).
+     * Returns an `Upload`; call `.run()` on it to start extraction.
+     */
+    upload(file?: File | null): Promise<Upload>;
+}
+
 /** Any extraction field — the discriminated union on `data_type`. */
 type Field = ExtractionSchema["fields"][number];
+/**
+ * A field that may appear inside an object. Excludes `object`: only one
+ * level of nesting is supported, so objects cannot contain objects.
+ */
+type NestedField = ObjectField["nested_fields"][number];
 type LookupOpt = {
     lookup?: boolean;
 };
@@ -1385,24 +1761,49 @@ declare const Schema: {
     datetime: (name: string, description: string, opts?: LookupOpt) => DatetimeField;
     enum: (name: string, description: string, options: EnumOption[], opts?: LookupOpt) => EnumField;
     multiSelect: (name: string, description: string, options: EnumOption[], opts?: LookupOpt) => MultiSelectField;
-    object: (name: string, description: string, fields: Field[], opts?: LookupOpt) => ObjectField;
+    object: (name: string, description: string, fields: NestedField[], opts?: LookupOpt) => ObjectField;
     option: (name: string, description: string) => EnumOption;
 };
 
-type ParseMode = "standard" | "agentic";
+type ExtractMode = "standard" | "agentic" | "max" | "lite";
+type AgenticEffort = "low" | "mid" | "accurate";
+type OcrEffort = "medium" | "high";
+type OcrRegion = "eu" | "global";
+type RoutingEffort = "minimal" | "low" | "medium" | "high";
 /** Source-port label routing into an extract/validate node. */
 type Branch = string | ClassifyCategory | SplitterRule;
-interface ParseOptions {
-    mode?: ParseMode;
+/** Knobs shared by every parse mode. */
+interface ParseOptionsBase {
     promptHint?: string;
     figureEnhancement?: boolean;
+    cache?: boolean;
     id?: string;
 }
+/**
+ * Parse options as a `mode`-discriminated union: each mode only accepts its own knobs, so a lite
+ * knob on `{ mode: "standard" }` is a compile-time error rather than a silent no-op. `mode` is
+ * optional only on the standard variant (the default), required on agentic/lite.
+ */
+type ParseOptions = (ParseOptionsBase & {
+    mode?: "standard";
+}) | (ParseOptionsBase & {
+    mode: "agentic";
+    effort?: AgenticEffort;
+}) | (ParseOptionsBase & {
+    mode: "lite";
+    ocrEffort?: OcrEffort;
+    region?: OcrRegion;
+    skipRoutingReview?: boolean;
+    figures?: boolean;
+    textFormatting?: boolean;
+    routingEffort?: RoutingEffort;
+});
 /**
  * Fluent assembler for a typed workflow graph — a faithful TS port of the
  * Python `WorkflowBuilder`. `parse`/`classify`/`split` are singletons;
  * `extract`/`validate` are repeatable and carry their edge metadata. Call
- * `build()` (or `create()`/`run()`) to emit the wire request.
+ * `build()` (or `create()`) to emit the wire request — submit with
+ * `Workflow.run(file)` on the handle that `create()` returns.
  */
 declare class WorkflowBuilder {
     private readonly client;
@@ -1429,8 +1830,11 @@ declare class WorkflowBuilder {
     extract(fields: Field[], opts?: {
         branch?: Branch;
         id?: string;
+        mode?: ExtractMode;
         lookupFiles?: string[];
         lookupSuggestion?: string;
+        lookupReasoningEffort?: RoutingEffort;
+        useImages?: boolean;
     }): this;
     validate(rules: ValidationRule[], opts?: {
         branch?: Branch;
@@ -1440,12 +1844,10 @@ declare class WorkflowBuilder {
     private normalizeExtractBranch;
     /** Assemble the wire request (branch-routed edges). Pure — no network. */
     build(): WorkflowCreateRequest;
-    /** Persist the workflow and return its id. */
-    create(): Promise<string>;
-    /** Create the workflow, submit a document, and return a pending `Run`. */
-    run(file?: File | null, opts?: {
-        text?: string;
-    }): Run;
+    /** Persist the workflow and return a handle you can `.run(file)` on. */
+    create(): Promise<Workflow>;
+    /** Replace an existing workflow's definition and return a handle you can `.run(file)` on. */
+    update(workflowId: string): Promise<Workflow>;
 }
 
 interface AnyformatOptions {
@@ -1459,6 +1861,27 @@ declare class Anyformat {
     readonly _client: Client;
     constructor(opts: AnyformatOptions);
     workflow(name: string, description?: string): WorkflowBuilder;
+    listWorkflows(opts?: {
+        page?: number;
+        pageSize?: number;
+        status?: string;
+    }): Promise<Workflow[]>;
+    deleteWorkflow(workflowId: string): Promise<string>;
+    /** Stage a document in a workflow without running it. Returns an `Upload`. */
+    upload(workflowId: string, file?: File | null): Promise<Upload>;
+    /** Trigger extraction on already-uploaded files. Returns a pending `Run` per file_id. */
+    runWorkflow(workflowId: string, fileIds: string[]): Promise<Run[]>;
+    /**
+     * Parse a document with the platform's atomic `/parse` operation (fast lite
+     * parse). Returns an opaque `jobId`; poll `getParseMarkdown(jobId)` for the
+     * parsed markdown.
+     */
+    parse(file: Blob | File): Promise<string>;
+    /**
+     * Poll a parse job. Returns the parsed markdown once the job is done, or
+     * `null` while it is still processing.
+     */
+    getParseMarkdown(jobId: string): Promise<string | null>;
 }
 
 declare class AnyformatError extends Error {
@@ -1468,22 +1891,34 @@ declare class APIError extends AnyformatError {
     readonly body?: unknown | undefined;
     constructor(status: number, message: string, body?: unknown | undefined);
 }
-declare class BadRequest extends APIError {
+declare class BadRequestError extends APIError {
 }
-declare class Unauthorized extends APIError {
+declare class UnauthorizedError extends APIError {
 }
-declare class Forbidden extends APIError {
+declare class ForbiddenError extends APIError {
 }
-declare class NotFound extends APIError {
+declare class NotFoundError extends APIError {
 }
-declare class RateLimited extends APIError {
+declare class RateLimitedError extends APIError {
 }
 declare class ServerError extends APIError {
 }
-declare class SDKTimeout extends AnyformatError {
+/** @deprecated Use `BadRequestError`. Alias for one minor release. */
+declare const BadRequest: typeof BadRequestError;
+/** @deprecated Use `UnauthorizedError`. Alias for one minor release. */
+declare const Unauthorized: typeof UnauthorizedError;
+/** @deprecated Use `ForbiddenError`. Alias for one minor release. */
+declare const Forbidden: typeof ForbiddenError;
+/** @deprecated Use `NotFoundError`. Alias for one minor release. */
+declare const NotFound: typeof NotFoundError;
+/** @deprecated Use `RateLimitedError`. Alias for one minor release. */
+declare const RateLimited: typeof RateLimitedError;
+declare class SDKTimeoutError extends AnyformatError {
 }
+/** @deprecated Use `SDKTimeoutError`. Alias for one minor release. */
+declare const SDKTimeout: typeof SDKTimeoutError;
 /** Raised by the fluent `WorkflowBuilder` for builder-API misuse. */
 declare class WorkflowBuilderError extends AnyformatError {
 }
 
-export { APIError, Anyformat, AnyformatError, type AnyformatOptions, BadRequest, type BooleanField, type Branch, type ClassifyCategory, type DateField, type DatetimeField, type EnumField, type EnumOption, type ExtractedField, type Extraction, type ExtractionSchema, type Field, type FloatField, Forbidden, type IntegerField, type MultiSelectField, NotFound, type ObjectField, RateLimited, Result, type ResultsResponse, Run, SDKTimeout, Schema, ServerError, type SplitterRule, type StringField, Unauthorized, type ValidationRule, type WaitOptions, WorkflowBuilder, WorkflowBuilderError, type WorkflowCreateRequest };
+export { APIError, Anyformat, AnyformatError, type AnyformatOptions, type ArithmeticCheck, BadRequest, BadRequestError, type Block, type BooleanField, type Branch, type ClassifyCategory, type ComparisonCheck, type DateCheck, type DateField, type DatetimeField, type EnumField, type EnumOption, type ExtractedField, type Extraction, type ExtractionSchema, type Field, type FloatField, Forbidden, ForbiddenError, type IntegerField, type MultiSelectField, type NestedField, NotFound, NotFoundError, type ObjectField, type OneOfCheck, ParseView, type RangeCheck, RateLimited, RateLimitedError, type RegexCheck, type RequiredCheck, Result, type ResultsResponse, Run, SDKTimeout, SDKTimeoutError, Schema, ServerError, type SplitterRule, type StringField, Unauthorized, UnauthorizedError, Upload, type ValidationRule, type WaitOptions, Workflow, WorkflowBuilder, WorkflowBuilderError, type WorkflowCreateRequest };