@opencraw/core 0.1.2 → 0.1.4

package/dist/recipe-schema/input-recipe.contract.d.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+import type { CrawlMode, KeepKind } from './recipe-kind.enum.js';
+import type { CaptchaCheck, ErrorPolicy, Step } from './step.contract.js';
+import type { MappingRule } from './transform-rule.contract.js';
+/** A URL the crawl starts from, with variables visible to its templates as `vars.*`. */
+export interface StartPoint {
+    url: string;
+    vars?: Record<string, string | number | boolean>;
+}
+/** A cookie in Playwright's shape. */
+export interface RecipeCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path?: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+/** Runs before the crawl, always in a browser, to obtain cookies or storage (a login, a consent wall). */
+export interface SessionBootstrap {
+    steps: Step[];
+    keep: KeepKind[];
+    /** Persist the resulting storage state for the next run. */
+    saveTo?: string;
+}
+/**
+ * What the site needs from the network, never how to get it: the runner's
+ * access config maps a profile name to a provider and credentials.
+ */
+export interface SessionAccess {
+    /** An access profile of the runner's config; its default when omitted. */
+    profile?: string;
+    /** ISO 3166 country the traffic should come from, for profiles that target by country. */
+    country?: string;
+    /** `false` lets the provider rotate IPs per request; the profile decides when omitted. */
+    sticky?: boolean;
+}
+/**
+ * What counts as the site refusing the crawl, checked on every navigation and
+ * request. Any condition that matches is a block. When omitted: status 403 or
+ * 429, or an AWS WAF challenge (`x-amzn-waf-action: challenge`).
+ */
+export interface BlockRule {
+    status?: number[];
+    /** Header name to a regular expression its value must match (case-insensitive). */
+    header?: Record<string, string>;
+    /** A regular expression the response body must match (case-insensitive). */
+    text?: string;
+}
+/**
+ * What to do when blocked. `solve`: when the block page shows a captcha, the
+ * `session.captcha` solver solves it on the spot. `rotate`: take a new access
+ * lease (a new IP), reopen the session, and retry the step; with `solve`, only
+ * once solving failed.
+ */
+export interface BlockRotation {
+    rotate?: boolean;
+    solve?: boolean;
+    /** How many rotations a recipe run may use. Default 2. */
+    attempts?: number;
+}
+/**
+ * How a web recipe gets past captchas: a solver the runner registered (a
+ * plugin's `captchaSolvers`), where to look for challenges, how to confirm
+ * one is solved, and what the run may spend. With it, the engine checks for a
+ * challenge after each navigation, click and key press, and solves it before
+ * the next step runs.
+ */
+export interface CaptchaSettings {
+    /** The name of a registered captcha solver. */
+    solver: string;
+    /** Where challenges are (a Playwright selector); the common widgets when omitted. */
+    detect?: {
+        selector: string;
+    };
+    /** How a solve is confirmed. Default: the challenge is gone. */
+    verify?: CaptchaCheck;
+    /** Solves tried per challenge before it counts as a block. Default 3. */
+    attempts?: number;
+    /** How long one solve may take. Default 120000. */
+    timeoutMs?: number;
+    /** Solves the whole run may spend (a paid solver bills each). Default 10; 0 detects without solving. */
+    maxSolves?: number;
+}
+export interface SessionSpec {
+    headers?: Record<string, string>;
+    cookies?: RecipeCookie[];
+    userAgent?: string;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    /** Reuse a storage state saved by a previous bootstrap. */
+    storageStatePath?: string;
+    bootstrap?: SessionBootstrap;
+    access?: SessionAccess;
+    blockedWhen?: BlockRule;
+    onBlock?: BlockRotation;
+    captcha?: CaptchaSettings;
+    /**
+     * A browser profile of the runner that persists between runs (cookies,
+     * storage, cache): web recipes and bootstraps run in it. A name; the runner
+     * decides where profiles live.
+     */
+    browserProfile?: string;
+}
+/**
+ * How a request that fails in passing (a dropped connection, a timeout, a
+ * 503, a 429) is sent again. On by default: three tries in all.
+ */
+export interface RetryRule {
+    /** Tries per request, the first included; `1` turns retrying off. Default 3. */
+    attempts?: number;
+    /** The first pause; it doubles on every retry. Default 1000. */
+    backoffMs?: number;
+    /** The longest pause, `Retry-After` included; a server asking for longer is not retried. Default 30000. */
+    maxDelayMs?: number;
+    /** The statuses retried. Default `[408, 425, 429, 500, 502, 503, 504]`. */
+    statuses?: number[];
+}
+export interface CrawlLimits {
+    maxRecords?: number;
+    /** Minimum interval between two request starts across the recipe, whatever runs in parallel. */
+    delayMs?: number;
+    timeoutMs?: number;
+    /** How many `forEach` iterations over a list may run at once: requests in api mode, tabs in web mode. Default 1. */
+    concurrency?: number;
+    /** How requests that fail in passing are sent again; the crawler's `retry`, else three tries, when omitted. */
+    retry?: RetryRule;
+}
+/** Where to start, how to navigate, what to extract, and how it maps to one output recipe. */
+export interface InputRecipe {
+    $schema?: string;
+    kind: 'input';
+    id: string;
+    /** The `OutputRecipe.id` this recipe feeds. */
+    output: string;
+    mode: CrawlMode;
+    description?: string;
+    start: StartPoint[];
+    vars?: Record<string, string | number | boolean>;
+    session?: SessionSpec;
+    limits?: CrawlLimits;
+    /** Default policy for every step. */
+    onError?: ErrorPolicy;
+    steps: Step[];
+    /** Keyed by output field path, dotted for nested fields. */
+    mapping: Record<string, MappingRule>;
+}
+export declare const startPointSchema: z.ZodType<StartPoint>;
+export declare const sessionSpecSchema: z.ZodType<SessionSpec>;
+export declare const retryRuleSchema: z.ZodType<RetryRule>;
+export declare const inputRecipeSchema: z.ZodType<InputRecipe>;
+//# sourceMappingURL=input-recipe.contract.d.ts.map

package/dist/recipe-schema/json-schema.mapper.d.ts

@@ -0,0 +1,15 @@
+/** A JSON Schema document, as `z.toJSONSchema` produces it. */
+export type JsonSchemaDocument = Record<string, unknown>;
+/**
+ * The JSON Schema for output recipe files, for editors and other tools.
+ *
+ * @returns A draft 2020-12 document.
+ */
+export declare function outputRecipeJsonSchema(): JsonSchemaDocument;
+/**
+ * The JSON Schema for input recipe files, for editors and other tools.
+ *
+ * @returns A draft 2020-12 document.
+ */
+export declare function inputRecipeJsonSchema(): JsonSchemaDocument;
+//# sourceMappingURL=json-schema.mapper.d.ts.map

package/dist/recipe-schema/output-recipe.contract.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import type { FieldType, GeneratedValue, MissingPolicy, RecipeMissingPolicy } from './recipe-kind.enum.js';
+/** One field of the records a crawl produces: its type, quality rules and what to do when it is missing. */
+export interface FieldSpec {
+    type: FieldType;
+    description?: string;
+    /** Default `false`. */
+    required?: boolean;
+    /** Default `false`. */
+    nullable?: boolean;
+    /** Used when the value is missing and the resolved policy is `default`. */
+    default?: unknown;
+    onMissing?: MissingPolicy;
+    /** Part of the record identity, used to drop duplicates. */
+    key?: boolean;
+    /** Supplied by the engine, never mapped. */
+    generated?: GeneratedValue;
+    /** Input format for `date` / `datetime`; output is always ISO 8601. */
+    format?: string;
+    /** ISO 4217 code for `currency`. */
+    currency?: string;
+    /** Allowed values for `enum`. */
+    values?: string[];
+    /** Element spec for `array`. */
+    items?: FieldSpec;
+    /** Member specs for `object`. A `json` field takes none: it keeps whatever it is given. */
+    fields?: Record<string, FieldSpec>;
+    min?: number;
+    max?: number;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+}
+/** The schema of the records every input recipe bound to it must produce. */
+export interface OutputRecipe {
+    $schema?: string;
+    kind: 'output';
+    id: string;
+    version: number;
+    description?: string;
+    fields: Record<string, FieldSpec>;
+    /** Recipe-wide default: `fail` for required fields, `null` otherwise. */
+    onMissing?: RecipeMissingPolicy;
+}
+export declare const fieldSpecSchema: z.ZodType<FieldSpec>;
+export declare const outputRecipeSchema: z.ZodType<OutputRecipe>;
+//# sourceMappingURL=output-recipe.contract.d.ts.map

package/dist/recipe-schema/recipe-kind.enum.d.ts

@@ -0,0 +1,35 @@
+/** The closed vocabularies a recipe file can use. Each is a `readonly` tuple so zod and TypeScript share it. */
+export declare const RECIPE_KINDS: readonly ['input', 'output'];
+export declare const CRAWL_MODES: readonly ['web', 'api'];
+export declare const SELECTOR_KINDS: readonly ['css', 'xpath', 'jsonpath', 'regex', 'table'];
+/** `take` also accepts `attr:<name>`, which is validated by pattern rather than listed. */
+export declare const TAKE_KINDS: readonly ['text', 'html', 'value', 'json'];
+export declare const BODY_KINDS: readonly ['json', 'jsonl', 'html', 'text', 'pdf', 'csv', 'xlsx', 'pptx', 'yaml', 'markdown', 'xml', 'docx'];
+export declare const YAML_SCALARS: readonly ['typed', 'text'];
+/** How a PDF table aligns a row's values against a cell wrapped over several lines. */
+export declare const TABLE_ALIGNS: readonly ['auto', 'top', 'center', 'bottom'];
+export declare const FIELD_TYPES: readonly ['string', 'number', 'integer', 'boolean', 'date', 'datetime', 'currency', 'url', 'enum', 'array', 'object', 'json'];
+export declare const MISSING_POLICIES: readonly ['fail', 'skip-record', 'null', 'default'];
+export declare const RECIPE_MISSING_POLICIES: readonly ['fail', 'skip-record', 'null'];
+export declare const ERROR_POLICIES: readonly ['fail', 'skip', 'retry'];
+export declare const GENERATED_VALUES: readonly ['now', 'uuid', 'sourceUrl', 'recipeId'];
+export declare const KEEP_KINDS: readonly ['cookies', 'localStorage'];
+export declare const WAIT_UNTIL: readonly ['load', 'domcontentloaded', 'networkidle', 'commit'];
+export declare const HTTP_METHODS: readonly ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'];
+/** Steps that only make sense with a live browser page. */
+export declare const WEB_ONLY_STEPS: readonly ['goto', 'click', 'fill', 'press', 'select', 'scroll', 'wait', 'evaluate', 'screenshot', 'captcha'];
+/** Steps that only make sense against an HTTP request context. */
+export declare const API_ONLY_STEPS: readonly ['request'];
+export type RecipeKind = typeof RECIPE_KINDS[number];
+export type CrawlMode = typeof CRAWL_MODES[number];
+export type SelectorKind = typeof SELECTOR_KINDS[number];
+export type BodyKind = typeof BODY_KINDS[number];
+export type TableAlign = typeof TABLE_ALIGNS[number];
+export type FieldType = typeof FIELD_TYPES[number];
+export type MissingPolicy = typeof MISSING_POLICIES[number];
+export type RecipeMissingPolicy = typeof RECIPE_MISSING_POLICIES[number];
+export type GeneratedValue = typeof GENERATED_VALUES[number];
+export type KeepKind = typeof KEEP_KINDS[number];
+export type WaitUntil = typeof WAIT_UNTIL[number];
+export type HttpMethod = typeof HTTP_METHODS[number];
+//# sourceMappingURL=recipe-kind.enum.d.ts.map

package/dist/recipe-schema/recipe-validation.error.d.ts

@@ -0,0 +1,17 @@
+/** One problem found in a recipe file, located by its JSON path. */
+export interface RecipeIssue {
+    /** Dotted JSON path, `''` for the root. */
+    path: string;
+    message: string;
+}
+/** A recipe that does not match its contract. `issues` lists every problem, not just the first. */
+export declare class RecipeValidationError extends Error {
+    /** Which recipe: a file path or an id when known. */
+    readonly source: string;
+    readonly issues: readonly RecipeIssue[];
+    readonly name = "RecipeValidationError";
+    constructor(
+    /** Which recipe: a file path or an id when known. */
+    source: string, issues: readonly RecipeIssue[]);
+}
+//# sourceMappingURL=recipe-validation.error.d.ts.map

package/dist/recipe-schema/recipe.validator.d.ts

@@ -0,0 +1,28 @@
+import type { InputRecipe } from './input-recipe.contract.js';
+import type { OutputRecipe } from './output-recipe.contract.js';
+/**
+ * Parses an unknown value (a decoded JSON file) as an output recipe.
+ *
+ * @param value - The decoded JSON.
+ * @param source - A name for error messages, usually the file path.
+ * @returns The typed recipe.
+ * @throws RecipeValidationError when it does not match the contract.
+ */
+export declare function parseOutputRecipe(value: unknown, source?: string): OutputRecipe;
+/**
+ * Parses an unknown value (a decoded JSON file) as an input recipe.
+ *
+ * @param value - The decoded JSON.
+ * @param source - A name for error messages, usually the file path.
+ * @returns The typed recipe.
+ * @throws RecipeValidationError when it does not match the contract.
+ */
+export declare function parseInputRecipe(value: unknown, source?: string): InputRecipe;
+/**
+ * Reads the `kind` of a decoded recipe without validating the rest.
+ *
+ * @param value - The decoded JSON.
+ * @returns `'input'`, `'output'`, or `undefined` when it is neither.
+ */
+export declare function recipeKindOf(value: unknown): 'input' | 'output' | undefined;
+//# sourceMappingURL=recipe.validator.d.ts.map

package/dist/recipe-schema/step.contract.d.ts

@@ -0,0 +1,206 @@
+import { z } from 'zod';
+import { TAKE_KINDS } from './recipe-kind.enum.js';
+import type { BodyKind, HttpMethod, SelectorKind, TableAlign, WaitUntil } from './recipe-kind.enum.js';
+/** What to do when a step fails. Resolved step -> recipe -> `fail`. */
+export type ErrorPolicy = {
+    policy: 'fail';
+} | {
+    policy: 'skip';
+} | {
+    policy: 'retry';
+    attempts: number;
+    backoffMs?: number;
+};
+/** What a value is taken from an element or JSON node: text, inner HTML, an attribute, an input value, or the node itself. */
+export type TakeKind = typeof TAKE_KINDS[number] | `attr:${string}`;
+/** How `paginate` finds the next page once the page body has run. */
+export type PaginateNext = {
+    selector: string;
+} | {
+    url: string;
+} | {
+    jsonpath: string;
+    as?: string;
+};
+export interface StepBaseFields {
+    /** Names the value this step produces. */
+    id?: string;
+    onError?: ErrorPolicy;
+    /** A template; the step runs only when it renders truthy. */
+    when?: string;
+}
+export interface GotoStep extends StepBaseFields {
+    type: 'goto';
+    url: string;
+    waitUntil?: WaitUntil;
+}
+/** Where an interaction lands: a selector, or a `target` template that renders to a live element (a `forEach` over `selector`) or to a selector string. */
+export interface TargetFields {
+    selector?: string;
+    target?: string;
+}
+export interface ClickStep extends StepBaseFields, TargetFields {
+    type: 'click';
+    optional?: boolean;
+}
+export interface FillStep extends StepBaseFields, TargetFields {
+    type: 'fill';
+    value: string;
+}
+export interface PressStep extends StepBaseFields, TargetFields {
+    type: 'press';
+    key: string;
+}
+/** Picks an option of a `<select>` by value, label or index. */
+export interface SelectStep extends StepBaseFields, TargetFields {
+    type: 'select';
+    value?: string;
+    label?: string;
+    index?: number;
+}
+export interface ScrollStep extends StepBaseFields {
+    type: 'scroll';
+    to: string;
+    times?: number;
+    untilStable?: boolean;
+}
+export interface WaitStep extends StepBaseFields {
+    type: 'wait';
+    selector?: string;
+    ms?: number;
+    state?: 'networkidle';
+}
+export interface EvaluateStep extends StepBaseFields {
+    type: 'evaluate';
+    script: string;
+}
+export interface ScreenshotStep extends StepBaseFields {
+    type: 'screenshot';
+    path: string;
+}
+export interface RequestStep extends StepBaseFields {
+    type: 'request';
+    method?: HttpMethod;
+    url: string;
+    query?: Record<string, string>;
+    headers?: Record<string, string>;
+    body?: unknown;
+    as?: BodyKind;
+    /** The body's text encoding (a WHATWG label, `windows-1252`); default: the BOM, the declared charset, UTF-8, else Windows-1252. */
+    encoding?: string;
+    /** A CSV body's delimiter (one character); default: detected among `,` `;` tab `|`. */
+    delimiter?: string;
+    /** A YAML body's scalars: `typed` (default, YAML 1.2) or `text`, every scalar as written (`0123` stays `"0123"`). */
+    scalars?: 'typed' | 'text';
+}
+export interface ExtractStep extends StepBaseFields {
+    type: 'extract';
+    selector: string;
+    kind: SelectorKind;
+    take?: TakeKind;
+    many?: boolean;
+    /** Id of a document or fragment to read instead of the current document. */
+    from?: string;
+    /** `table` only: output key -> a pattern (case-insensitive) for that column's header cell. */
+    columns?: Record<string, string>;
+    /** `table` only: a pattern (case-insensitive) for the row that ends a table. */
+    until?: string;
+    /** `table` only: how a row's values sit against a cell wrapped over several lines (PDF); default `auto`. */
+    align?: TableAlign;
+    /** `table` only: a pattern (case-insensitive) for the names of the sheets to read (workbook); default every sheet. */
+    sheet?: string;
+    /** `table` only: how many rows the header spans (workbook); a column's key joins its header texts. Default 1. */
+    headerRows?: number;
+    /** `table` only: output keys whose empty cells take the value of the row above. */
+    fillDown?: string[];
+    /** `table` only: read hidden sheets and rows (workbook) or hidden slides (deck) too. */
+    includeHidden?: boolean;
+    /** `table` only: a pattern (case-insensitive) for the titles of the slides to read (deck); default every slide. */
+    slide?: string;
+    /** `table` only: read text boxes laid out as a table instead of native tables (deck). */
+    shapes?: boolean;
+    /** `xpath` on XML only: prefix to namespace URI (`{ "atom": "http://www.w3.org/2005/Atom" }`). Prefixes the root declares are known already. */
+    namespaces?: Record<string, string>;
+    /** `xpath` on XML only: drop the document's namespaces, so `//entry/title` matches `<entry xmlns="…">`. */
+    ignoreNamespaces?: boolean;
+}
+export interface SetStep extends StepBaseFields {
+    type: 'set';
+    value: unknown;
+}
+/**
+ * Appends to a list bound in an enclosing scope (a `set` to `[]` before the
+ * loop), so values gathered page by page or item by item outlive the child
+ * scope that found them. A list value is appended item by item.
+ */
+export interface CollectStep extends StepBaseFields {
+    type: 'collect';
+    into: string;
+    value: unknown;
+}
+/** Runs a body per item of a list (`over`) or per live element matching `selector` (web mode; the elements are re-resolved on every use). */
+export interface ForEachStep extends StepBaseFields {
+    type: 'forEach';
+    over?: string;
+    selector?: string;
+    as: string;
+    steps: Step[];
+    emit?: true | {
+        output: string;
+    };
+}
+/** Runs `steps` when `test` renders truthy, else `else`; both in the current scope. */
+export interface IfStep extends StepBaseFields {
+    type: 'if';
+    test: string;
+    steps: Step[];
+    else?: Step[];
+}
+export interface PaginateStep extends StepBaseFields {
+    type: 'paginate';
+    next: PaginateNext;
+    until?: string;
+    maxPages?: number;
+    steps: Step[];
+}
+export interface EmitStep extends StepBaseFields {
+    type: 'emit';
+    output?: string;
+}
+export interface HookStep extends StepBaseFields {
+    type: 'hook';
+    name: string;
+    args?: Record<string, unknown>;
+}
+/**
+ * How the engine confirms a captcha was solved (it never takes the solver's
+ * word): the challenge is gone, and/or an element appears.
+ */
+export interface CaptchaCheck {
+    /** The detected challenge must be off the page. Default `true`. */
+    gone?: boolean;
+    /** An element that must appear once solved. */
+    selector?: string;
+}
+/**
+ * Solves the captcha on the live page, if there is one (none is not an error):
+ * a challenge known to sit at one point of the crawl, a login form. The solver
+ * and the defaults come from `session.captcha`, unless the step names its own.
+ */
+export interface CaptchaStep extends StepBaseFields {
+    type: 'captcha';
+    /** A captcha solver the runner registered; `session.captcha.solver` when omitted. */
+    solver?: string;
+    /** Where the challenge is (a Playwright selector); the common widgets when omitted. */
+    selector?: string;
+    verify?: CaptchaCheck;
+    attempts?: number;
+    timeoutMs?: number;
+}
+export type Step = GotoStep | ClickStep | FillStep | PressStep | SelectStep | ScrollStep | WaitStep | EvaluateStep | ScreenshotStep | RequestStep | ExtractStep | SetStep | CollectStep | ForEachStep | IfStep | PaginateStep | EmitStep | HookStep | CaptchaStep;
+export type StepType = Step['type'];
+export declare const errorPolicySchema: z.ZodType<ErrorPolicy>;
+export declare const paginateNextSchema: z.ZodType<PaginateNext>;
+export declare const captchaCheckSchema: z.ZodType<CaptchaCheck>;
+export declare const stepSchema: z.ZodType<Step>;
+//# sourceMappingURL=step.contract.d.ts.map

package/dist/recipe-schema/transform-rule.contract.d.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+import type { MissingPolicy } from './recipe-kind.enum.js';
+/** One operation in a mapping chain. The set is closed: extension happens through `hook`. */
+export type TransformRule = {
+    op: 'trim';
+} | {
+    op: 'lowercase';
+} | {
+    op: 'uppercase';
+} | {
+    op: 'replace';
+    pattern: string;
+    replacement: string;
+    flags?: string;
+} | {
+    op: 'regex';
+    pattern: string;
+    group?: number;
+    flags?: string;
+} | {
+    op: 'split';
+    separator: string;
+} | {
+    op: 'join';
+    separator: string;
+} | {
+    op: 'first';
+} | {
+    op: 'last';
+} | {
+    op: 'nth';
+    index: number;
+} | {
+    op: 'slice';
+    start: number;
+    end?: number;
+} | {
+    op: 'concat';
+    separator?: string;
+} | {
+    op: 'coalesce';
+} | {
+    op: 'default';
+    value: unknown;
+} | {
+    op: 'number';
+    locale?: string;
+} | {
+    op: 'integer';
+} | {
+    op: 'boolean';
+    truthy?: string[];
+} | {
+    op: 'currency';
+    locale?: string;
+    currency?: string;
+} | {
+    op: 'date';
+    format?: string;
+    timezone?: string;
+} | {
+    op: 'absoluteUrl';
+    base?: string;
+} | 
+/** Percent-encodes text for one URL component (`encodeURIComponent`). */
+{
+    op: 'urlEncode';
+} | {
+    op: 'flatten';
+} | {
+    op: 'unique';
+} | {
+    op: 'sum';
+} | {
+    op: 'count';
+} | {
+    op: 'template';
+    value: string;
+} | {
+    op: 'jsonpath';
+    path: string;
+} | 
+/** Finds the item of a table (an id or path in scope) whose `key` path equals the input; yields `pick` from it, or the item. */
+{
+    op: 'lookup';
+    in: string;
+    key: string;
+    pick?: string;
+} | 
+/** Groups a list by a path into `[{ key, items }]`, first-seen order. */
+{
+    op: 'group';
+    by: string;
+} | {
+    op: 'hook';
+    name: string;
+    args?: Record<string, unknown>;
+};
+export type TransformOp = TransformRule['op'];
+/** Binds one output field to extracted values. */
+export type MappingRule = {
+    from: string | string[];
+    transform?: TransformRule[];
+    onMissing?: MissingPolicy;
+} | 
+/** Builds an array of objects from a list: `fields` paths are relative to each list item. */
+{
+    each: string;
+    fields: Record<string, MappingRule>;
+    onMissing?: MissingPolicy;
+};
+export type FromRule = Extract<MappingRule, {
+    from: unknown;
+}>;
+export type EachRule = Extract<MappingRule, {
+    each: unknown;
+}>;
+export declare const transformRuleSchema: z.ZodType<TransformRule>;
+export declare const mappingRuleSchema: z.ZodType<MappingRule>;
+//# sourceMappingURL=transform-rule.contract.d.ts.map

package/dist/record-diff/index.d.ts

@@ -0,0 +1,4 @@
+export { diffRecords, diffOptionsFor, readableKey } from './record-diff.algorithm.js';
+export type { RecordDiff, RecordChange, FieldChange, DiffOptions, StoredRecord } from './record-diff.algorithm.js';
+export { readRecordsFile } from './records-file.repository.js';
+//# sourceMappingURL=index.d.ts.map