@anyformat/sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1420 @@
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: unknown) => unknown;
+type QuerySerializerOptionsObject = {
+    allowReserved?: boolean;
+    array?: Partial<SerializerOptions<ArrayStyle>>;
+    object?: Partial<SerializerOptions<ObjectStyle>>;
+};
+type QuerySerializerOptions = QuerySerializerOptionsObject & {
+    /**
+     * Per-parameter serialization overrides. When provided, these settings
+     * override the global array/object settings for specific parameter names.
+     */
+    parameters?: Record<string, QuerySerializerOptionsObject>;
+};
+
+type HttpMethod = 'connect' | 'delete' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+type Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never, SseFn = never> = {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    getConfig: () => Config;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+} & {
+    [K in HttpMethod]: MethodFn;
+} & ([SseFn] extends [never] ? {
+    sse?: never;
+} : {
+    sse: {
+        [K in HttpMethod]: SseFn;
+    };
+});
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: Uppercase<HttpMethod>;
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g., converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type ServerSentEventsOptions<TData = unknown> = Omit<RequestInit, 'method'> & Pick<Config$1, 'method' | 'responseTransformer' | 'responseValidator'> & {
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Implementing clients can call request interceptors inside this hook.
+     */
+    onRequest?: (url: string, init: RequestInit) => Promise<Request>;
+    /**
+     * Callback invoked when a network or parsing error occurs during streaming.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param error The error that occurred.
+     */
+    onSseError?: (error: unknown) => void;
+    /**
+     * Callback invoked when an event is streamed from the server.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @param event Event streamed from the server.
+     * @returns Nothing (void).
+     */
+    onSseEvent?: (event: StreamEvent<TData>) => void;
+    serializedBody?: RequestInit['body'];
+    /**
+     * Default retry delay in milliseconds.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 3000
+     */
+    sseDefaultRetryDelay?: number;
+    /**
+     * Maximum number of retry attempts before giving up.
+     */
+    sseMaxRetryAttempts?: number;
+    /**
+     * Maximum retry delay in milliseconds.
+     *
+     * Applies only when exponential backoff is used.
+     *
+     * This option applies only if the endpoint returns a stream of events.
+     *
+     * @default 30000
+     */
+    sseMaxRetryDelay?: number;
+    /**
+     * Optional sleep function for retry backoff.
+     *
+     * Defaults to using `setTimeout`.
+     */
+    sseSleepFn?: (ms: number) => Promise<void>;
+    url: string;
+};
+interface StreamEvent<TData = unknown> {
+    data: TData;
+    event?: string;
+    id?: string;
+    retry?: number;
+}
+type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
+    stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    fns: Array<Interceptor | null>;
+    clear(): void;
+    eject(id: number | Interceptor): void;
+    exists(id: number | Interceptor): boolean;
+    getInterceptorIndex(id: number | Interceptor): number;
+    update(id: number | Interceptor, fn: Interceptor): number | Interceptor | false;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Interceptors<ErrInterceptor<Err, Res, Req, Options>>;
+    request: Interceptors<ReqInterceptor<Req, Options>>;
+    response: Interceptors<ResInterceptor<Res, Req, Options>>;
+}
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TData = unknown, TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}>, Pick<ServerSentEventsOptions<TData>, 'onRequest' | 'onSseError' | 'onSseEvent' | 'sseDefaultRetryDelay' | 'sseMaxRetryAttempts' | 'sseMaxRetryDelay'> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
+}>;
+interface ClientOptions {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: TData & Options<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn, SseFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+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'>);
+
+/**
+ * Block
+ *
+ * One semantic block of a parsed document — a structured alternative to
+ * walking `<a id></a>` anchors in `markdown`.
+ *
+ * All blocks expose the common fields (`id`, `type`, `page`, `bbox`,
+ * `confidence`, `content`). Type-specific structured data lives in the
+ * optional fields (`rows` for tables, `image_base64` for pictures).
+ * Consumers can switch on `type` to access the per-type fields, or treat
+ * `content` as the universal fallback.
+ */
+type Block = {
+    /**
+     * Bbox
+     *
+     * Normalised bounding box in [0, 1] page coordinates with keys `x0`/`y0`/`x1`/`y1`.
+     */
+    bbox: {
+        [key: string]: number;
+    };
+    /**
+     * Content
+     *
+     * Raw section body — markdown for text/title blocks, HTML for tables, `<figure-content>` for pictures.
+     */
+    content: string;
+    /**
+     * Hyperlinks
+     *
+     * Hyperlinks found in the content via `[text](uri)` markdown syntax.
+     */
+    hyperlinks?: Array<Hyperlink>;
+    /**
+     * Id
+     *
+     * Stable block identifier in the form `p<page>_b<index>`.
+     */
+    id: string;
+    /**
+     * Image Base64
+     *
+     * Inline base64-encoded cropped image for `type=picture` blocks. Currently `null` for all blocks — image hydration is performed client-side by the SDK consumer.
+     */
+    image_base64?: string | null;
+    /**
+     * Layout Confidence
+     *
+     * 0-100 YOLO layout detection confidence for this block.
+     */
+    layout_confidence: number;
+    /**
+     * Page
+     *
+     * 1-indexed page number this block belongs to.
+     */
+    page: number;
+    /**
+     * Parse Confidence
+     *
+     * 0-100 parse confidence calibrated from LLM logprobs. `null` when logprobs were unavailable (e.g. text-bytes strategy).
+     */
+    parse_confidence?: number | null;
+    /**
+     * Rows
+     *
+     * 2D array of table cells for `type=table` blocks — each cell is `{cell_id, text}`. `null` for non-table blocks.
+     */
+    rows?: Array<Array<{
+        [key: string]: string;
+    }>> | null;
+    /**
+     * Type
+     *
+     * Semantic type: `text`, `title`, `section-header`, `table`, `picture`, `other`.
+     */
+    type: string;
+};
+/**
+ * BooleanField
+ */
+type BooleanField = {
+    /**
+     * Data Type
+     */
+    data_type: 'boolean';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+};
+/**
+ * ClassificationResult
+ *
+ * One classifier verdict for the collection.
+ */
+type ClassificationResult = {
+    /**
+     * Category
+     *
+     * The category the document was classified as.
+     */
+    category: string;
+    /**
+     * Confidence
+     *
+     * 0-100 model confidence in the verdict.
+     */
+    confidence: number;
+    /**
+     * Evidence
+     *
+     * Free-form evidence text (the snippets the classifier cited). `null` when none captured.
+     */
+    evidence?: string | null;
+};
+/**
+ * ClassifyCategory
+ */
+type ClassifyCategory = {
+    /**
+     * Description
+     *
+     * Free-form description shown to the LLM.
+     */
+    description: string;
+    /**
+     * Id
+     *
+     * Stable category id used as the edge `branch` value when routing.
+     */
+    id: string;
+    /**
+     * Name
+     *
+     * Display name shown to the LLM.
+     */
+    name: string;
+};
+/**
+ * ClassifyNode
+ */
+type ClassifyNode = {
+    /**
+     * Categories
+     */
+    categories: Array<ClassifyCategory>;
+    /**
+     * Id
+     *
+     * Stable identifier for this node within the graph.
+     */
+    id: string;
+    /**
+     * Type
+     */
+    type: 'classify';
+    /**
+     * User Prompt
+     *
+     * Optional prompt prefix for the classifier.
+     */
+    user_prompt?: string | null;
+};
+/**
+ * DateField
+ */
+type DateField = {
+    /**
+     * Data Type
+     */
+    data_type: 'date';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+};
+/**
+ * DatetimeField
+ */
+type DatetimeField = {
+    /**
+     * Data Type
+     */
+    data_type: 'datetime';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+};
+/**
+ * Edge
+ *
+ * A directed edge between two nodes. ``branch`` carries the source-port label
+ * used for routing out of ``classify`` (category id) or ``splitter`` (rule id) nodes.
+ */
+type Edge = {
+    /**
+     * Branch
+     *
+     * Source-port label for branch routing. Required when leaving a classify or splitter node by category/rule.
+     */
+    branch?: string | null;
+    /**
+     * Source
+     */
+    source: string;
+    /**
+     * Target
+     */
+    target: string;
+};
+/**
+ * EnumField
+ */
+type EnumField = {
+    /**
+     * Data Type
+     */
+    data_type: 'enum';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Enum Options
+     */
+    enum_options: Array<EnumOption>;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+};
+/**
+ * EnumOption
+ */
+type EnumOption = {
+    /**
+     * Description
+     *
+     * Free-form description shown to the model.
+     */
+    description: string;
+    /**
+     * Name
+     */
+    name: string;
+};
+/**
+ * Evidence
+ *
+ * A snippet of source text supporting an extracted value, with the page it came from.
+ */
+type Evidence = {
+    /**
+     * Page Number
+     *
+     * 1-indexed page number where the snippet was found.
+     */
+    page_number: number;
+    /**
+     * Text
+     *
+     * The exact source-text snippet that supports the extracted value.
+     */
+    text: string;
+};
+/**
+ * ExtractNode
+ */
+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.
+     */
+    extraction_schema: ExtractionSchema;
+    /**
+     * Id
+     *
+     * Stable identifier for this node within the graph.
+     */
+    id: string;
+    /**
+     * Lookup Files
+     *
+     * Smart-lookup reference document URIs persisted on the extract node.
+     */
+    lookup_files?: Array<string>;
+    /**
+     * 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)>;
+    /**
+     * Lookup Suggestion
+     *
+     * Free-form hint shown to the smart-lookup matcher.
+     */
+    lookup_suggestion?: string | null;
+    /**
+     * Mode
+     */
+    mode?: 'standard' | 'agentic';
+    /**
+     * Type
+     */
+    type: 'extract';
+    /**
+     * Use Images
+     */
+    use_images?: boolean;
+};
+/**
+ * ExtractedField
+ *
+ * One extracted field's value, confidence, and supporting evidence.
+ */
+type ExtractedField = {
+    /**
+     * Confidence
+     *
+     * Model confidence in the extracted value, on a 0-100 scale. `null` when the backend did not produce a confidence (e.g. manual entry).
+     */
+    confidence?: number | null;
+    /**
+     * Evidence
+     *
+     * Source-text snippets the model used to derive this value.
+     */
+    evidence?: Array<Evidence>;
+    /**
+     * Value
+     *
+     * The extracted value. Type depends on the field's `data_type` (string, number, date, etc.). `null` when extraction could not produce a value.
+     */
+    value: unknown | null;
+    /**
+     * Value Override
+     *
+     * A human-supplied override of the extracted `value`, if one was set during verification. `null` when no override exists.
+     */
+    value_override?: unknown | null;
+    /**
+     * Verification Status
+     *
+     * Verification state for this datapoint (e.g. `not_verified`, `verified`). `null` when not yet reviewed.
+     */
+    verification_status?: string | null;
+};
+/**
+ * Extraction
+ *
+ * One unit of extracted data. For linear (parse->extract) workflows there
+ * is exactly one entry with `split_name=null` and `partition=null`. For split
+ * workflows there is one entry per (split, partition) pair; join with
+ * `splits[]` by `split_name` to look up geometry.
+ */
+type Extraction = {
+    /**
+     * Fields
+     *
+     * Extracted fields keyed by field name. Same shape as the legacy top-level `extraction`.
+     */
+    fields: {
+        [key: string]: ExtractedField | Array<{
+            [key: string]: ExtractedField;
+        }>;
+    };
+    /**
+     * Partition
+     *
+     * The partition value within the split. `null` when the split has no partitions.
+     */
+    partition?: string | null;
+    /**
+     * Split Name
+     *
+     * The split category this extraction belongs to. `null` for linear workflows.
+     */
+    split_name?: string | null;
+};
+/**
+ * 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.
+ *
+ * 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.
+ */
+type ExtractionSchema = {
+    /**
+     * Fields
+     *
+     * 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)>;
+};
+/**
+ * FilePages
+ *
+ * A file's contribution of pages to a split or partition. 1-indexed.
+ */
+type FilePages = {
+    /**
+     * File Id
+     *
+     * The file's UUID.
+     */
+    file_id: string;
+    /**
+     * File Name
+     *
+     * The file's display name.
+     */
+    file_name: string;
+    /**
+     * Pages
+     *
+     * 1-indexed page numbers from this file.
+     */
+    pages: Array<number>;
+};
+/**
+ * FloatField
+ */
+type FloatField = {
+    /**
+     * Data Type
+     */
+    data_type: 'float';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+};
+/**
+ * Hyperlink
+ *
+ * A hyperlink found inside a block's content.
+ */
+type Hyperlink = {
+    /**
+     * Text
+     *
+     * The display text of the link.
+     */
+    text: string;
+    /**
+     * Uri
+     *
+     * The link target (URL, mailto:, etc.).
+     */
+    uri: string;
+};
+/**
+ * IntegerField
+ */
+type IntegerField = {
+    /**
+     * Data Type
+     */
+    data_type: 'integer';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+};
+/**
+ * MultiSelectField
+ */
+type MultiSelectField = {
+    /**
+     * Data Type
+     */
+    data_type: 'multi_select';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Enum Options
+     */
+    enum_options: Array<EnumOption>;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+};
+/**
+ * ObjectField
+ */
+type ObjectField = {
+    /**
+     * Data Type
+     */
+    data_type: 'object';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+    /**
+     * Nested Fields
+     */
+    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)>;
+};
+/**
+ * ParseNode
+ */
+type ParseNode = {
+    /**
+     * Figure Enhancement
+     */
+    figure_enhancement?: boolean;
+    /**
+     * Id
+     *
+     * Stable identifier for this node within the graph.
+     */
+    id: string;
+    /**
+     * Mode
+     */
+    mode?: 'standard' | 'agentic';
+    /**
+     * Prompt Hint
+     *
+     * Free-form hint shown to the parse model to bias output.
+     */
+    prompt_hint?: string | null;
+    /**
+     * Type
+     */
+    type: 'parse';
+};
+/**
+ * ParseResult
+ *
+ * Parsed markdown for a file.
+ */
+type ParseResult = {
+    /**
+     * Blocks
+     *
+     * Structured per-block representation of the parsed document. One entry per `<a id></a>` anchor in document order, with type-specific structured data (`rows` for tables, `image_base64` for pictures) surfaced as first-class fields so consumers don't have to HTML-parse.
+     */
+    blocks?: Array<Block>;
+    /**
+     * Layout Confidence
+     *
+     * Document-level YOLO layout confidence on a 0-100 scale, char-weighted mean across all blocks. `null` if no annotated sections.
+     */
+    layout_confidence?: number | null;
+    /**
+     * Markdown
+     *
+     * Document content rendered as structured markdown. Each block is preceded by an empty `<a id="p{page}_b{idx}"></a>` anchor (invisible in any markdown renderer; the id joins to `blocks[].id` and can be used as an in-page link target). Image hydration for picture/figure blocks happens client-side. `null` if parsing failed.
+     */
+    markdown: string | null;
+    /**
+     * Parse Confidence
+     *
+     * Document-level parse confidence on a 0-100 scale, char-weighted mean of per-block LLM logprob scores. `null` when no blocks have logprob-based confidence.
+     */
+    parse_confidence?: number | null;
+    /**
+     * Text
+     *
+     * Plain markdown with structural HTML removed — `<DOCUMENT>` framing, block anchors, `<img>` tags, and `<figure-content>` wrappers stripped. Useful when feeding the parsed output into an LLM or a search index that doesn't need the block-level metadata. `null` if `markdown` is null.
+     */
+    text?: string | null;
+};
+/**
+ * ResultsResponse
+ *
+ * Canonical response shape for the file-collection results endpoint.
+ *
+ * Returned with HTTP 200 once processing completes. Returns 412 while processing is
+ * in progress; poll until 200, or use webhooks.
+ */
+type ResultsResponse = {
+    /**
+     * Classifications
+     *
+     * Per-classifier-node verdicts. Empty when the workflow has no classifier.
+     */
+    classifications?: Array<ClassificationResult>;
+    /**
+     * Collection Id
+     *
+     * The file collection's UUID. Same value as the `id` returned by `POST /v2/workflows/{wid}/run/`.
+     */
+    collection_id: string;
+    /**
+     * Extraction
+     *
+     * **Deprecated** — use `extractions` instead. Extracted fields keyed by field name, populated only for linear workflows (single extract node, no splitter). `null` for split workflows; read `extractions[]` instead.
+     *
+     * @deprecated
+     */
+    extraction?: {
+        [key: string]: ExtractedField | Array<{
+            [key: string]: ExtractedField;
+        }>;
+    } | null;
+    /**
+     * Extractions
+     *
+     * Flat list of extraction datapoints. Linear workflows produce one entry with `split_name=null` and `partition=null`. Split workflows produce one entry per (split, partition). Empty when no extraction has run yet.
+     */
+    extractions?: Array<Extraction>;
+    /**
+     * Parse-node output (rendered markdown). `null` when the workflow has no parse node. Always present in the response.
+     */
+    parse?: ParseResult | null;
+    /**
+     * Splits
+     *
+     * Splitter output: category-level geometry with optional partitions. Empty when the workflow has no splitter.
+     */
+    splits?: Array<SplitResult>;
+    /**
+     * Verification Url
+     *
+     * Link to the AnyFormat dashboard for human review of this collection's results. `null` if the dashboard URL cannot be constructed (e.g. no files in the collection, or the deployment has no frontend URL configured).
+     */
+    verification_url?: string | null;
+};
+/**
+ * SplitPartition
+ *
+ * A partition value within a split (e.g. `1234-5678` under `Account Holdings`).
+ */
+type SplitPartition = {
+    /**
+     * Confidence
+     *
+     * 0-100 minimum confidence across the partition's ranges.
+     */
+    confidence: number;
+    /**
+     * Files
+     */
+    files: Array<FilePages>;
+    /**
+     * Name
+     *
+     * The partition value (free-form string).
+     */
+    name: string;
+};
+/**
+ * SplitResult
+ *
+ * A category-level split: which pages of which files fall under it, plus
+ * any partitions inside it. Extraction data lives under `extractions[]` —
+ * join by `split_name`.
+ */
+type SplitResult = {
+    /**
+     * Confidence
+     *
+     * 0-100 aggregate confidence (min across partitions).
+     */
+    confidence: number;
+    /**
+     * Files
+     *
+     * Per-file page lists, union of all partitions.
+     */
+    files: Array<FilePages>;
+    /**
+     * Name
+     *
+     * The split's category name.
+     */
+    name: string;
+    /**
+     * Partitions
+     */
+    partitions?: Array<SplitPartition>;
+};
+/**
+ * SplitterNode
+ */
+type SplitterNode = {
+    /**
+     * Id
+     *
+     * Stable identifier for this node within the graph.
+     */
+    id: string;
+    /**
+     * Rules
+     */
+    rules: Array<SplitterRule>;
+    /**
+     * Type
+     */
+    type: 'splitter';
+};
+/**
+ * SplitterRule
+ */
+type SplitterRule = {
+    /**
+     * Description
+     */
+    description: string;
+    /**
+     * Id
+     */
+    id: string;
+    /**
+     * Name
+     */
+    name: string;
+    /**
+     * Partition Key
+     */
+    partition_key?: string;
+};
+/**
+ * StringField
+ */
+type StringField = {
+    /**
+     * Data Type
+     */
+    data_type: 'string';
+    /**
+     * Description
+     *
+     * Free-form description shown to the extraction model.
+     */
+    description: string;
+    /**
+     * Name
+     *
+     * Field name. Used as the key in the extraction response.
+     */
+    name: string;
+};
+/**
+ * ValidateNode
+ */
+type ValidateNode = {
+    /**
+     * Id
+     *
+     * Stable identifier for this node within the graph.
+     */
+    id: string;
+    /**
+     * Rules
+     */
+    rules: Array<ValidationRule>;
+    /**
+     * Type
+     */
+    type: 'validate';
+};
+/**
+ * ValidationRule
+ */
+type ValidationRule = {
+    /**
+     * Description
+     *
+     * Natural-language description shown to the validation model.
+     */
+    description: string;
+    /**
+     * Id
+     *
+     * Stable rule id; round-trips through ValidationResult.rule_id.
+     */
+    id: string;
+    /**
+     * 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.
+     */
+    name?: string | null;
+    /**
+     * Severity
+     */
+    severity?: 'error' | 'warning';
+    /**
+     * Source Fields
+     *
+     * Persistent ids of fields this rule references.
+     */
+    source_fields?: Array<string>;
+};
+/**
+ * WorkflowCreateRequest
+ *
+ * Public-surface workflow create body — typed graph of parse / classify / splitter / extract nodes.
+ *
+ * Defined as a thin subclass so the FastAPI-generated OpenAPI components
+ * entry is named ``WorkflowCreateRequest`` (FastAPI uses the model's
+ * ``__name__``). Behaviour is fully inherited from
+ * ``WorkflowDefinition`` in ``anyformat.workflow``.
+ */
+type WorkflowCreateRequest = {
+    /**
+     * Description
+     */
+    description?: string | null;
+    /**
+     * Edges
+     */
+    edges?: Array<Edge>;
+    /**
+     * Name
+     */
+    name: string;
+    /**
+     * Nodes
+     */
+    nodes: Array<({
+        type: 'parse';
+    } & ParseNode) | ({
+        type: 'classify';
+    } & ClassifyNode) | ({
+        type: 'splitter';
+    } & SplitterNode) | ({
+        type: 'extract';
+    } & ExtractNode) | ({
+        type: 'validate';
+    } & ValidateNode)>;
+};
+
+/** Typed wrapper over a completed run's results. */
+declare class Result {
+    readonly raw: ResultsResponse;
+    constructor(raw: ResultsResponse);
+    get collectionId(): string;
+    get extractions(): Extraction[];
+    /**
+     * 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.
+     */
+    field(name: string): ExtractedField | undefined;
+}
+
+interface WaitOptions {
+    /** Overall budget before giving up. Default 120s. */
+    timeoutMs?: number;
+    /** Delay between result polls. Default 2s. */
+    pollMs?: number;
+}
+/**
+ * A pending run. Lazily creates the workflow, submits the document, and
+ * polls for results when `wait()` is awaited.
+ */
+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;
+    wait(opts?: WaitOptions): Promise<Result>;
+}
+
+/** Any extraction field — the discriminated union on `data_type`. */
+type Field = ExtractionSchema["fields"][number];
+/**
+ * Factory for extraction-schema fields — the TS mirror of the Python
+ * `Schema` facade. Each method returns the typed wire model the API
+ * validates against; the discriminator (`data_type`) is filled in for you.
+ */
+declare const Schema: {
+    readonly string: (name: string, description: string) => StringField;
+    readonly integer: (name: string, description: string) => IntegerField;
+    readonly float: (name: string, description: string) => FloatField;
+    readonly boolean: (name: string, description: string) => BooleanField;
+    readonly date: (name: string, description: string) => DateField;
+    readonly datetime: (name: string, description: string) => DatetimeField;
+    readonly enum: (name: string, description: string, options: EnumOption[]) => EnumField;
+    readonly multiSelect: (name: string, description: string, options: EnumOption[]) => MultiSelectField;
+    readonly object: (name: string, description: string, fields: Field[]) => ObjectField;
+    readonly option: (name: string, description: string) => EnumOption;
+};
+
+type ParseMode = "standard" | "agentic";
+/** Source-port label routing into an extract/validate node. */
+type Branch = string | ClassifyCategory | SplitterRule;
+interface ParseOptions {
+    mode?: ParseMode;
+    promptHint?: string;
+    figureEnhancement?: boolean;
+    id?: string;
+}
+/**
+ * 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.
+ */
+declare class WorkflowBuilder {
+    private readonly client;
+    private readonly name;
+    private readonly description?;
+    private parseNode;
+    private classifyNode;
+    private splitNode;
+    private splitRouteFrom;
+    private readonly extracts;
+    private readonly validates;
+    private readonly idCounters;
+    constructor(client: Client, name: string, description?: string | undefined);
+    private nextId;
+    private require;
+    parse(opts?: ParseOptions): this;
+    classify(categories: ClassifyCategory[], opts?: {
+        id?: string;
+    }): this;
+    split(rules: SplitterRule[], opts?: {
+        routeFrom?: string | ClassifyCategory;
+        id?: string;
+    }): this;
+    extract(fields: Field[], opts?: {
+        branch?: Branch;
+        id?: string;
+    }): this;
+    validate(rules: ValidationRule[], opts?: {
+        branch?: Branch;
+        id?: string;
+    }): this;
+    private normalizeClassifyBranch;
+    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?: Blob | File | null, opts?: {
+        text?: string;
+    }): Run;
+}
+
+interface AnyformatOptions {
+    apiKey: string;
+    /** Override the API base URL (defaults to production). */
+    baseUrl?: string;
+}
+/** Entry point. `new Anyformat({ apiKey }).workflow("name").parse()...` */
+declare class Anyformat {
+    /** @internal */
+    readonly _client: Client;
+    constructor(opts: AnyformatOptions);
+    workflow(name: string, description?: string): WorkflowBuilder;
+}
+
+declare class AnyformatError extends Error {
+}
+declare class APIError extends AnyformatError {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+declare class BadRequest extends APIError {
+}
+declare class Unauthorized extends APIError {
+}
+declare class Forbidden extends APIError {
+}
+declare class NotFound extends APIError {
+}
+declare class RateLimited extends APIError {
+}
+declare class ServerError extends APIError {
+}
+declare class SDKTimeout extends AnyformatError {
+}
+/** 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 };