@relyio/sdk 0.18.0 → 0.20.0

package/dist/automations/index.d.cts

@@ -1,1309 +1,4 @@
-import { ConditionScalar, ConditionTest, ConditionTree, ConditionTests } from '../schema/index.cjs';
+import '../define-content-type-C2HnCYYX.cjs';
+export { a0 as Accepts, au as AgentStepConfig, ag as AnyEntryEvent, ah as AnyEntryTriggers, aG as ApproveCounts, aH as ApproveOutput, aF as ApproveStepConfig, aE as AskOutput, aD as AskStepConfig, aq as AutomationAction, I as AutomationBecomesTest, aJ as AutomationConfig, Z as AutomationDefinition, T as AutomationDuration, G as AutomationEntryAction, aK as AutomationFile, P as AutomationInput, ab as AutomationItemHandle, U as AutomationItemRef, L as AutomationJson, V as AutomationLookupState, aw as AutomationProposal, X as AutomationProposeTarget, E as AutomationRecordAction, N as AutomationRef, Y as AutomationStep, ar as AutomationStepDraft, $ as AutomationTemplate, K as AutomationTrigger, a6 as AutomationTriggerHandle, O as AutomationValue, J as AutomationWhere, a8 as EntryEvent, ad as EntryTriggers, an as ExtensionTriggerEvent, aB as LookedUp, aA as LookedUpEntry, az as LookedUpEntryItem, ay as LookedUpRecord, aC as LookupOptions, av as ProposingAgentStepConfig, ax as ProposingOutput, a7 as RecordEvent, ac as RecordTriggers, _ as Ref, ak as RunFailedEvent, al as RunFailedWhere, aI as StepBuilder, as as StepHandle, a1 as StepInput, at as StepWithOutput, a9 as TriggerWhere, aa as UidRef, a3 as and, ai as anyEntry, am as automations, aL as defineAutomation, af as entries, ao as extensionTrigger, aM as isAutomationFile, a5 as not, ap as on, a4 as or, ae as records, aN as resolveAutomation, aj as schedule, a2 as tpl } from '../index-DImzg3ew.cjs';
 export { fields } from '../schema/index.cjs';
-import { A as AnySchemaDefinition, R as RegisteredSchema, B as BaseRecord, a as RecordBatchTarget, b as RecordBatchResult, c as RecordConditionValue } from '../register-BYCs0FpF.cjs';
-import { S as SchemaRecordTypeNames, I as InferRecordType, a as SchemaContentTypeNames, b as SchemaEntry, c as SchemaLocaleCodes, R as RecordWriteFieldsOf, d as RecordUpdateFieldsOf } from '../define-schema-DZhtvLiK.cjs';
-import { K as KeyedMembers, F as FieldValues, D as DeclaredFields, a as KeyedMembersOf, b as FileUpload } from '../define-content-type-NEQDrvdq.cjs';
 import '../rich-text.d-BWc-5gX1.cjs';
-
-/**
- * `@relyio/sdk/automations` — an Automation, declared (spec 3, REL-3845; ADR 0021).
- *
- * One file per Automation at `relyio/automations/<name>.ts`, default-exporting what
- * {@link defineAutomation} returns; the file's name is the Automation's. An Automation is a trigger
- * and a sequence of steps, and all of it is data: `steps` is called **once**, when the Manifest
- * loads, with typed references to the event and to earlier steps' outputs, and returns plain data.
- * No code of yours runs when an event arrives, except inside a Function step.
- *
- * @example
- * // relyio/automations/order-paid.ts
- * import { defineAutomation, fields, or, records, tpl } from '@relyio/sdk/automations'
- * import reserveStock from '../functions/reserve-stock'
- *
- * export default defineAutomation({
- *   on: records.order.updated({ where: { status: { becomes: 'paid' } } }),
- *   steps: ({ event, step }) => {
- *     const reserve = step.fn('reserve', reserveStock, { orderId: event.record._metadata.id })
- *     const fraud = step.agent('fraud', {
- *       instructions: tpl`Read order ${event.record.number} and the customer's past orders`,
- *       context: { order: event.record },
- *       output: { verdict: fields.enum({ options: { 'looks fine': 'Looks fine', 'needs review': 'Needs review' } }) },
- *     })
- *     return [reserve, fraud, step.if('ship', fraud.output.verdict.eq('looks fine'), { then: […] })]
- *   },
- * })
- *
- * **Typed.** Once `relyio generate-types` has registered the schema (`Register`), `records.<type>`
- * takes only the Record types it declares and `event.record` is typed by its fields. A Function
- * step takes the Function by import, so its input is checked against the Function's input Fields and
- * its `output` has exactly the Function's output Fields: a misspelt one is a type error, and so is a
- * step reading one declared after it. The plan refuses both again, for a Manifest read as data.
- *
- * **Conditions** are the list grammar's operators (`eq`, `ne`, `in`, `gt`, `exists`, …) on a
- * reference, combined with {@link and}, {@link or} and {@link not}. `becomes` — changed in this
- * write and now equal — is a trigger's `where` alone.
- *
- * **Extensions** (REL-3846): `relyio/extensions.ts` declares the Extensions the Project uses with
- * `defineExtensions` (`@relyio/sdk/extensions`), and hands out a typed handle for each. An Automation
- * imports it: `on: stripe.paymentIntentSucceeded()` starts on one of its Triggers, and
- * `step.action('email', resend.send, { … })` sends through one of its Actions — input and output
- * typed by the Extension. Using an Extension the file does not declare is refused by the plan.
- */
-
-/** What a Record event says happened to one Record. */
-type AutomationRecordAction = 'created' | 'updated' | 'deleted' | 'expired';
-/** What an entry event says happened to one entry. */
-type AutomationEntryAction = 'created' | 'updated' | 'published' | 'unpublished' | 'deleted' | 'archived' | 'restored';
-/** A `becomes` test: changed in this write and now equal. A trigger's `where` alone holds one. */
-interface AutomationBecomesTest {
-    readonly root: 'event';
-    readonly path: readonly string[];
-    readonly operator: 'becomes';
-    readonly value: ConditionScalar;
-}
-/** A trigger's `where`: a condition over `event`, whose tests may also be `becomes`. */
-type AutomationWhere = ConditionTest | AutomationBecomesTest | {
-    readonly and: readonly AutomationWhere[];
-} | {
-    readonly or: readonly AutomationWhere[];
-} | {
-    readonly not: AutomationWhere;
-};
-/** An Automation's trigger, as data. */
-type AutomationTrigger = {
-    readonly kind: 'record';
-    readonly recordType: string;
-    readonly action: AutomationRecordAction;
-    readonly where?: AutomationWhere;
-} | {
-    readonly kind: 'entry';
-    readonly contentType: string;
-    readonly action: AutomationEntryAction;
-    readonly where?: AutomationWhere;
-}
-/**
- * An entry of any content type: `where` is a plain condition over {@link AnyEntryEvent} — the
- * entry's uid and content type, and what changed — with no `becomes`.
- */
- | {
-    readonly kind: 'anyEntry';
-    readonly action: AutomationEntryAction;
-    readonly where?: ConditionTree;
-} | {
-    readonly kind: 'schedule';
-    readonly cron: string;
-    readonly timezone: string;
-}
-/** Another Automation's run failed; `where` is a plain condition over {@link RunFailedEvent}. */
- | {
-    readonly kind: 'runFailed';
-    readonly where?: ConditionTree;
-}
-/**
- * One of an Extension's Triggers: `trigger` is its slug in the Extension catalog. `where` is a plain
- * condition over {@link ExtensionTriggerEvent}.
- */
- | {
-    readonly kind: 'extension';
-    readonly extension: string;
-    readonly trigger: string;
-    readonly where?: ConditionTree;
-};
-/** A JSON value, as a step's input holds it literally. */
-type AutomationJson = string | number | boolean | null | readonly AutomationJson[] | {
-    readonly [key: string]: AutomationJson;
-};
-/** A reference: the value at `path` under `root` — `event`, or an earlier step's name. */
-interface AutomationRef {
-    readonly kind: 'ref';
-    readonly root: string;
-    readonly path: readonly string[];
-}
-/** A value a step is handed, as data. */
-type AutomationValue = {
-    readonly kind: 'literal';
-    readonly value: AutomationJson;
-} | AutomationRef | {
-    readonly kind: 'template';
-    readonly parts: ReadonlyArray<string | AutomationRef>;
-} | {
-    readonly kind: 'list';
-    readonly items: readonly AutomationValue[];
-} | {
-    readonly kind: 'object';
-    readonly fields: Readonly<Record<string, AutomationValue>>;
-};
-/** A step's input, by key. */
-type AutomationInput = Readonly<Record<string, AutomationValue>>;
-/** A Wait's length: whole minutes, hours or days, at most 30 days. */
-type AutomationDuration = `${number}m` | `${number}h` | `${number}d`;
-/** One Record or entry by its uid: what a Look-up reads. */
-type AutomationItemRef = {
-    readonly kind: 'record';
-    readonly recordType: string;
-    readonly uid: AutomationValue;
-} | {
-    readonly kind: 'entry';
-    readonly contentType: string;
-    readonly uid: AutomationValue;
-};
-/** Which of an entry's states a Look-up reads: what readers see, or the editor's view. */
-type AutomationLookupState = 'published' | 'draft';
-/** A type an Agent step may propose a change to: a content type's entries, or a Record type's. */
-type AutomationProposeTarget = {
-    readonly kind: 'entry';
-    readonly contentType: string;
-} | {
-    readonly kind: 'record';
-    readonly recordType: string;
-};
-/** One Automation step, as data. */
-type AutomationStep = {
-    readonly kind: 'function';
-    readonly name: string;
-    readonly function: string;
-    readonly input: AutomationInput;
-} | {
-    readonly kind: 'agent';
-    readonly name: string;
-    readonly agent?: string;
-    readonly instructions: AutomationValue;
-    readonly context: AutomationInput;
-    readonly output: readonly object[];
-    readonly propose?: readonly AutomationProposeTarget[];
-} | {
-    readonly kind: 'action';
-    readonly name: string;
-    readonly extension: string;
-    readonly action: string;
-    readonly input: AutomationInput;
-} | {
-    readonly kind: 'lookup';
-    readonly name: string;
-    readonly item: Extract<AutomationItemRef, {
-        readonly kind: 'record';
-    }>;
-} | {
-    readonly kind: 'lookup';
-    readonly name: string;
-    readonly item: Extract<AutomationItemRef, {
-        readonly kind: 'entry';
-    }>;
-    readonly state: AutomationLookupState;
-} | {
-    readonly kind: 'if';
-    readonly name: string;
-    readonly condition: ConditionTree;
-    readonly then: readonly AutomationStep[];
-    readonly else: readonly AutomationStep[];
-} | {
-    readonly kind: 'wait';
-    readonly name: string;
-    readonly duration: AutomationDuration;
-} | {
-    readonly kind: 'ask';
-    readonly name: string;
-    readonly to: readonly string[];
-    readonly question: AutomationValue;
-    readonly choices: readonly string[];
-    readonly timeout: AutomationDuration;
-    readonly onTimeout?: string;
-    readonly sample?: string;
-    readonly approve?: AutomationRef;
-};
-/** What an Automation declares, as data: what the Manifest carries for one file. */
-interface AutomationDefinition {
-    readonly description?: string;
-    readonly on: AutomationTrigger;
-    /** What each run is about: one Record or entry (REL-3853). */
-    readonly about?: AutomationItemRef;
-    readonly steps: readonly AutomationStep[];
-}
-/** Where a reference's value type rides, for the compiler alone. */
-declare const REF_VALUE: unique symbol;
-/** A list is compared by its members, as a condition compares a list. */
-type MemberOf<T> = T extends ReadonlyArray<infer Member> ? Member : T;
-/** The values a path holding `T` is compared with. */
-type ComparedWith<T> = unknown extends T ? ConditionScalar : MemberOf<NonNullable<T>> extends infer Member ? Member extends ConditionScalar ? Member : never : never;
-/** `becomes`, offered on a trigger's `where` alone. */
-interface BecomesTest<T> {
-    /** Changed in this write, and now equal to `value`. */
-    becomes(value: ComparedWith<T>): AutomationBecomesTest;
-}
-/**
- * The paths under a reference to `T`. Where its shape is not known — no schema registered — a
- * reference is `any`: an index signature would read every step as possibly undefined under
- * `noUncheckedIndexedAccess`, and a typed project registers its schema.
- */
-type RefChildren<T, B extends boolean> = unknown extends T ? any : NonNullable<T> extends readonly unknown[] ? unknown : NonNullable<T> extends object ? {
-    readonly [K in keyof NonNullable<T> & string]-?: Ref<NonNullable<T>[K], B>;
-} : unknown;
-/**
- * A reference to a value of type `T` when the step runs: hand it to a step's input, interpolate it
- * with {@link tpl}, or test it (`.eq(…)`, `.in([…])`, `.exists()`) for a condition. A field named like
- * a test (`eq`, `in`) is not reachable as a path. `B`: whether `becomes` is offered (a `where`).
- */
-type Ref<T, B extends boolean = false> = {
-    readonly [REF_VALUE]: T;
-} & ConditionTests<T> & (B extends true ? BecomesTest<T> : unknown) & RefChildren<T, B>;
-/** A reference whose value is a `T`: what a step's input takes where it takes a `T`. */
-type RefTo<T> = {
-    readonly [REF_VALUE]: T;
-};
-/** Where a template's parts ride at run time. */
-declare const TEMPLATE: unique symbol;
-/** Text written with {@link tpl}: literal parts and references, rendered when the step runs. */
-interface AutomationTemplate {
-    readonly [TEMPLATE]: ReadonlyArray<string | AutomationRef>;
-}
-/** What a step's input takes where its Field takes a `T`. */
-type Accepts<T> = T | RefTo<T> | (string extends NonNullable<T> ? AutomationTemplate : never) | AcceptsWithin<NonNullable<T>>;
-/**
- * A list or object a step's input takes, references at any depth. Distributed over each member of
- * `T`, so a union — `AutomationJson`, a webhook's body — takes a list or an object holding
- * references, as one member alone does.
- */
-type AcceptsWithin<T> = T extends ReadonlyArray<infer Member> ? ReadonlyArray<Accepts<Member>> : T extends object ? {
-    readonly [K in keyof T]: Accepts<T[K]>;
-} : never;
-/** A step's input: each key as its Field types it, a value or a reference to one. */
-type StepInput<V> = {
-    readonly [K in keyof V]: Accepts<V[K]>;
-};
-/**
- * Text with references in it, rendered when the step runs.
- *
- * @example
- * tpl`Order ${event.record.number} held: ${fraud.output.reason}`
- */
-declare function tpl(strings: TemplateStringsArray, ...values: ReadonlyArray<RefTo<unknown> | ConditionScalar>): AutomationTemplate;
-/** Every test holds. */
-declare function and(...conditions: readonly ConditionTree[]): ConditionTree;
-declare function and(...conditions: readonly AutomationWhere[]): AutomationWhere;
-/** Some test holds. */
-declare function or(...conditions: readonly ConditionTree[]): ConditionTree;
-declare function or(...conditions: readonly AutomationWhere[]): AutomationWhere;
-/** The test does not hold. */
-declare function not(condition: ConditionTree): ConditionTree;
-declare function not(condition: AutomationWhere): AutomationWhere;
-/** Where a trigger's event type rides, for the compiler alone. */
-declare const EVENT_TYPE: unique symbol;
-/** A trigger, as `on` takes it: its data, and the type of the event it hands `steps`. */
-interface AutomationTriggerHandle<E> {
-    readonly trigger: AutomationTrigger;
-    readonly [EVENT_TYPE]?: E;
-}
-/** The Record type names a schema declares, or any name without one. */
-type RecordTypeNameIn$1<S> = S extends AnySchemaDefinition ? SchemaRecordTypeNames<S> : string;
-type ContentTypeNameIn<S> = S extends AnySchemaDefinition ? SchemaContentTypeNames<S> : string;
-/** An entry's values, of one content type, typed by the registered schema when there is one. */
-type EntryValuesIn<S, K> = S extends AnySchemaDefinition ? Omit<SchemaEntry<S, K & SchemaContentTypeNames<S>>, '_metadata'> : Record<string, unknown>;
-/** A Record of one Record type, typed by the registered schema when there is one. */
-type RecordIn$1<S, K> = S extends AnySchemaDefinition ? InferRecordType<NonNullable<S['recordTypes']>[K & keyof NonNullable<S['recordTypes']>]> : BaseRecord;
-/** A Record event: the Record as the write left it, and the names of the fields it changed. */
-interface RecordEvent<R> {
-    readonly record: R;
-    readonly changed: readonly string[];
-}
-/** An entry event: the entry as the write left it, and the names of the fields it changed. */
-interface EntryEvent {
-    readonly entry: unknown;
-    readonly changed: readonly string[];
-}
-/** One field's `where`: its value, or the list grammar's operators and `becomes`. */
-type FieldWhere<T> = ComparedWith<T> | ({
-    readonly becomes?: ComparedWith<T>;
-} & {
-    readonly [Op in 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte']?: ComparedWith<T>;
-} & {
-    readonly in?: ReadonlyArray<ComparedWith<T>>;
-    readonly nin?: ReadonlyArray<ComparedWith<T>>;
-    readonly exists?: boolean;
-});
-/**
- * A trigger's `where`: field by field over the item — `{ status: { becomes: 'paid' } }`, every field
- * holding — or a condition over the event, written with `becomes` and the list grammar.
- */
-type TriggerWhere<E, Item> = {
-    readonly [F in keyof Item & string]?: FieldWhere<Item[F]>;
-} | ((event: Ref<E, true>) => AutomationWhere);
-/** Where a type's item rides at run time: `records.order` says it is the Record type `order`. */
-declare const ITEM: unique symbol;
-/** Where one item by uid rides at run time: what `<type>.ref(uid)` returns. */
-declare const ITEM_REF: unique symbol;
-/** Where a type's or an item's value type rides, for the compiler alone. */
-declare const ITEM_TYPE: unique symbol;
-/** What a type, or one item of it, holds: a Record of `R`, or an entry with the values `V`. */
-type ItemType<R = unknown, V = unknown> = {
-    readonly kind: 'record';
-    readonly record: R;
-} | {
-    readonly kind: 'entry';
-    readonly values: V;
-};
-/** The type a Record or entry type's handle names, as data. */
-type ItemTypeOf = {
-    readonly kind: 'record';
-    readonly recordType: string;
-} | {
-    readonly kind: 'entry';
-    readonly contentType: string;
-};
-/**
- * A uid: a reference to one — `event.record._metadata.id`, a reference field, an earlier step's
- * output — or a uid written out.
- */
-type UidRef = string | RefTo<string | null | undefined>;
-/**
- * One Record or entry, by its uid, typed by its type: `records.order.ref(event.record._metadata.id)`.
- * `step.lookup` reads one, and a run may be declared to be about one (REL-4152).
- */
-interface AutomationItemHandle<I extends ItemType = ItemType> {
-    readonly [ITEM_REF]: AutomationItemRef;
-    readonly [ITEM_TYPE]?: I;
-}
-/** The triggers of one Record type. */
-interface RecordTriggers<R> {
-    /** A typed reference to one Record of this type, by its uid. */
-    ref(uid: UidRef): AutomationItemHandle<{
-        readonly kind: 'record';
-        readonly record: R;
-    }>;
-    readonly [ITEM]: ItemTypeOf;
-    readonly [ITEM_TYPE]?: {
-        readonly kind: 'record';
-        readonly record: R;
-    };
-    created(options?: {
-        where?: TriggerWhere<RecordEvent<R>, R>;
-    }): AutomationTriggerHandle<RecordEvent<R>>;
-    updated(options?: {
-        where?: TriggerWhere<RecordEvent<R>, R>;
-    }): AutomationTriggerHandle<RecordEvent<R>>;
-    deleted(options?: {
-        where?: TriggerWhere<RecordEvent<R>, R>;
-    }): AutomationTriggerHandle<RecordEvent<R>>;
-    expired(options?: {
-        where?: TriggerWhere<RecordEvent<R>, R>;
-    }): AutomationTriggerHandle<RecordEvent<R>>;
-}
-/** The triggers of one content type, whose entries hold the values `V`. */
-type EntryTriggers<V = Record<string, unknown>> = {
-    readonly [A in AutomationEntryAction]: (options?: {
-        where?: TriggerWhere<EntryEvent, Record<string, unknown>>;
-    }) => AutomationTriggerHandle<EntryEvent>;
-} & {
-    /** A typed reference to one entry of this type, by its uid. */
-    ref(uid: UidRef): AutomationItemHandle<{
-        readonly kind: 'entry';
-        readonly values: V;
-    }>;
-    readonly [ITEM]: ItemTypeOf;
-    readonly [ITEM_TYPE]?: {
-        readonly kind: 'entry';
-        readonly values: V;
-    };
-};
-/** Each Record type's triggers, by name: typed by the registered schema, any name without one. */
-type RecordTriggerTable = string extends RecordTypeNameIn$1<RegisteredSchema> ? {
-    readonly [recordType: string]: any;
-} : {
-    readonly [K in RecordTypeNameIn$1<RegisteredSchema>]: RecordTriggers<RecordIn$1<RegisteredSchema, K>>;
-};
-/** Each content type's triggers, by name. */
-type EntryTriggerTable = string extends ContentTypeNameIn<RegisteredSchema> ? {
-    readonly [contentType: string]: any;
-} : {
-    readonly [K in ContentTypeNameIn<RegisteredSchema>]: EntryTriggers<EntryValuesIn<RegisteredSchema, K>>;
-};
-/**
- * `records.<type>.created | updated | deleted | expired`: a Record event of one Record type.
- * `records.<type>` itself names the type to `step.lookup`, and `records.<type>.ref(uid)` one Record.
- */
-declare const records: RecordTriggerTable;
-/**
- * `entries.<type>.created | updated | published | …`: an entry event of one content type.
- * `entries.<type>` itself names the type to `step.lookup`, and `entries.<type>.ref(uid)` one entry.
- */
-declare const entries: EntryTriggerTable;
-/**
- * What a run started by an entry of any content type reads under `event` (REL-3861): what every
- * entry event holds whatever its type — the entry's uid and content type, and the names of the
- * fields the write changed. No field of the entry: no one content type declares it.
- */
-interface AnyEntryEvent {
-    readonly entry: {
-        readonly _metadata: {
-            readonly id: string;
-            readonly type: string;
-        };
-    };
-    readonly changed: readonly string[];
-}
-/** The triggers of an entry of any content type, one per entry action. */
-type AnyEntryTriggers = {
-    readonly [A in AutomationEntryAction]: (options?: {
-        readonly where?: (event: Ref<AnyEntryEvent>) => ConditionTree;
-    }) => AutomationTriggerHandle<AnyEntryEvent>;
-};
-/**
- * `anyEntry.created | updated | published | …`: an entry event of any content type — what a site
- * that revalidates every page it renders listens to. `where` is a function of the event, which holds
- * the entry's `_metadata.id` and `_metadata.type` and `changed` alone, and no `becomes`:
- * `anyEntry.published({ where: event => event.entry._metadata.type.in(['post']) })`.
- */
-declare const anyEntry: AnyEntryTriggers;
-/** A clock: `schedule.cron('0 8 * * 1', { timezone: 'Europe/Berlin' })`, on Production only. */
-declare const schedule: {
-    cron(cron: string, options: {
-        readonly timezone: string;
-    }): AutomationTriggerHandle<Record<string, never>>;
-};
-/**
- * What a run started by another run's failure reads under `event` (REL-4152): the failed run, its
- * Automation and Branch, what it was about, the step it failed at, the error, and the event that set
- * it off by type and id. Never that event's body: a Record's values stay on the failed run.
- */
-interface RunFailedEvent {
-    readonly runId: string;
-    /** The Automation whose run failed. */
-    readonly automation: string;
-    readonly branchId: string;
-    /** The Record or entry the failed run was about — and so the one this run is about. */
-    readonly about: {
-        readonly kind: 'record' | 'entry';
-        readonly type: string;
-        readonly uid: string;
-    } | null;
-    readonly step: {
-        readonly name: string;
-        /** `function`, `agent`, `action`, `if` or `wait`. */
-        readonly kind: string;
-        readonly attempts: number;
-    };
-    readonly error: {
-        readonly code: string;
-        readonly message: string;
-    };
-    readonly trigger: {
-        readonly eventType: string;
-        readonly eventId: string;
-    };
-}
-/** One value's `where` with no `becomes`: the value, or the list grammar's operators. */
-type ValueWhere<T> = ComparedWith<T> | ({
-    readonly [Op in 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte']?: ComparedWith<T>;
-} & {
-    readonly in?: ReadonlyArray<ComparedWith<T>>;
-    readonly nin?: ReadonlyArray<ComparedWith<T>>;
-    readonly exists?: boolean;
-});
-/** Where each name a failed run's `where` shorthand filters on sits under `event`. */
-declare const RUN_FAILED_PATHS: {
-    readonly automation: readonly ["automation"];
-    readonly step: readonly ["step", "name"];
-    readonly code: readonly ["error", "code"];
-};
-/**
- * A failed run's `where`: by its Automation, the step it failed at and the error's code —
- * `{ automation: 'order-paid', code: { in: ['send-refused'] } }`, every one holding — or a condition
- * over {@link RunFailedEvent}. No `becomes`: a failure changes no field.
- */
-type RunFailedWhere = {
-    readonly [K in keyof typeof RUN_FAILED_PATHS]?: ValueWhere<string>;
-} | ((event: Ref<RunFailedEvent>) => ConditionTree);
-/**
- * Another Automation's run failed: `automations.runFailed({ where })`, on the failed run's Branch.
- * An Automation never hears its own failure, and a run a failure started never announces its own.
- */
-declare const automations: {
-    runFailed(options?: {
-        readonly where?: RunFailedWhere;
-    }): AutomationTriggerHandle<RunFailedEvent>;
-};
-/**
- * What a run started by an Extension's Trigger reads under `event`: what the third party sent, as the
- * Trigger's payload fields declare it (`event.payload.data.object.id`).
- */
-interface ExtensionTriggerEvent<P> {
-    readonly payload: P;
-}
-/**
- * One of an Extension's Triggers, as its handle in `relyio/extensions.ts` builds it: the Extension by
- * slug, the Trigger by its slug in the catalog, and `where`, a plain condition over the event — no
- * `becomes`, since the third party's event names no field RelyIO saw change. Call the handle
- * (`stripe.paymentIntentSucceeded({ where })`) rather than this.
- */
-declare function extensionTrigger<P>(extension: string, trigger: string, options?: {
-    readonly where?: (event: Ref<ExtensionTriggerEvent<P>>) => ConditionTree;
-}): AutomationTriggerHandle<ExtensionTriggerEvent<P>>;
-/**
- * Every trigger, under one name: `on.records.order.updated(…)`, as `records.order.updated(…)`. An
- * Extension's Trigger is its handle's: `on: stripe.paymentIntentSucceeded()`.
- */
-declare const on: {
-    readonly records: {
-        readonly [recordType: string]: any;
-    };
-    readonly entries: {
-        readonly [contentType: string]: any;
-    };
-    readonly anyEntry: AnyEntryTriggers;
-    readonly schedule: {
-        cron(cron: string, options: {
-            readonly timezone: string;
-        }): AutomationTriggerHandle<Record<string, never>>;
-    };
-    readonly automations: {
-        runFailed(options?: {
-            readonly where?: RunFailedWhere;
-        }): AutomationTriggerHandle<RunFailedEvent>;
-    };
-};
-/** An Extension's Action, as `relyio/extensions.ts` hands one out (REL-3846): input and output typed. */
-interface AutomationAction<I = Record<string, unknown>, O = Record<string, unknown>, E extends string = string, N extends string = string> {
-    readonly _tag: 'action';
-    /** The Extension, by slug: a handle from `relyio/extensions.ts` carries it as a literal type. */
-    readonly extension: E;
-    /**
-     * The Action, by its slug in the Extension catalog: what the step stores, and what a Function's
-     * `actions.<extension>.<action>` names it by (REL-3856).
-     */
-    readonly action: N;
-    /** Never present at run time: the Action's input and output, as types. */
-    readonly [REF_VALUE]?: {
-        readonly input: I;
-        readonly output: O;
-    };
-}
-/** A step as `steps` builds it: its data, a Function step's Function still the imported value. */
-type AutomationStepDraft = (Omit<Extract<AutomationStep, {
-    kind: 'function';
-}>, 'function'> & {
-    readonly function: FunctionDefinition;
-}) | Exclude<AutomationStep, {
-    kind: 'function' | 'if';
-}> | (Omit<Extract<AutomationStep, {
-    kind: 'if';
-}>, 'then' | 'else'> & {
-    readonly then: readonly AutomationStepDraft[];
-    readonly else: readonly AutomationStepDraft[];
-});
-/** Where a step handle's data rides at run time. */
-declare const STEP: unique symbol;
-/** A step, as `steps` returns it and an If's branches list it. */
-interface StepHandle {
-    readonly name: string;
-    readonly [STEP]: AutomationStepDraft;
-}
-/** A step whose output later steps read: `<step>.output.<field>`. */
-interface StepWithOutput<O> extends StepHandle {
-    readonly output: Ref<O>;
-}
-/** A Field set's values, as a Function's and an Agent step's output Fields declare them. */
-type ValuesOf$1<F extends KeyedMembers> = FieldValues<DeclaredFields<{
-    readonly fields: readonly KeyedMembersOf<F>[];
-}>>;
-/** What `step.agent` takes. */
-interface AgentStepConfig<O extends KeyedMembers> {
-    /** The agent, built-in or the project's, by id or slug; RelyIO's default when left out. */
-    readonly agent?: string;
-    readonly instructions: string | AutomationTemplate;
-    /** What the agent is handed to read, by key. */
-    readonly context?: {
-        readonly [key: string]: unknown;
-    };
-    /** The Fields its answer must fill: a mismatch fails the step. */
-    readonly output: O;
-}
-/**
- * What a proposing `step.agent` takes besides (REL-4154): the types it may propose a change to —
- * `entries.productPage`, `records.order`. It is offered ai-gateway's proposal tools for those types
- * alone and makes at most one proposal, which nothing applies until an Ask approves it.
- */
-interface ProposingAgentStepConfig<O extends KeyedMembers> extends AgentStepConfig<O> {
-    readonly propose: readonly [LookupType, ...LookupType[]];
-}
-/** The proposal a proposing Agent step made: what an Ask's `approve` names. */
-interface AutomationProposal {
-    readonly id: string;
-    /** The proposal's kind: `field_update`, `operation`, `record_update`, … */
-    readonly kind: string;
-    /** How many units it changes: entries, or Records. */
-    readonly counts: {
-        readonly units: number;
-    };
-}
-/** A proposing Agent step's output: its Fields, and the proposal — `null` when it proposed none. */
-type ProposingOutput<V> = V & {
-    readonly proposal: AutomationProposal | null;
-};
-/**
- * What a Look-up of a Record answers: `found`, and the Record as it stands now when it was. Read
- * `found` before the Record: an item deleted, never there, or a reference with no value is
- * `{ found: false }`.
- */
-interface LookedUpRecord<R> {
-    readonly found: boolean;
-    readonly record?: R;
-}
-/** The locale codes the registered schema declares, or any code without one. */
-type LocaleCodeIn<S> = S extends AnySchemaDefinition ? SchemaLocaleCodes<S> : string;
-/** An entry as a Look-up reads it: its shared values, and each locale it admits with its own. */
-interface LookedUpEntryItem<V> {
-    readonly _metadata: {
-        readonly id: string;
-        readonly type: string;
-    };
-    /** The values of the fields that are not localized. */
-    readonly fields: Partial<V>;
-    /** Each locale the state admits: its publication status and its localized values. */
-    readonly locales: {
-        readonly [L in LocaleCodeIn<RegisteredSchema>]?: {
-            readonly status: 'published' | 'draft';
-            readonly fields: Partial<V>;
-        };
-    };
-}
-/** What a Look-up of an entry answers: `found`, and the entry when it was. */
-interface LookedUpEntry<V> {
-    readonly found: boolean;
-    readonly entry?: LookedUpEntryItem<V>;
-}
-type IsAny<T> = 0 extends 1 & T ? true : false;
-/** What a Look-up of the type or item `H` answers. */
-type LookedUp<H> = IsAny<H> extends true ? {
-    readonly found: boolean;
-    readonly record?: any;
-    readonly entry?: any;
-} : H extends {
-    readonly [ITEM_TYPE]?: infer I;
-} ? I extends {
-    readonly kind: 'record';
-    readonly record: infer R;
-} ? LookedUpRecord<R> : I extends {
-    readonly kind: 'entry';
-    readonly values: infer V;
-} ? LookedUpEntry<V> : never : never;
-/** What a Look-up of `H` takes beside it: an entry's `state`; a Record has no draft. */
-type LookupOptions<H> = IsAny<H> extends true ? {
-    readonly state?: AutomationLookupState;
-} : H extends {
-    readonly [ITEM_TYPE]?: {
-        readonly kind: 'entry';
-    };
-} ? {
-    /** `published` (the default): what readers see. `draft`: the editor's view. */
-    readonly state?: AutomationLookupState;
-} : never;
-/** A Record or entry type, as `step.lookup` takes it: `records.order`, `entries.product`. */
-type LookupType = {
-    readonly [ITEM]: ItemTypeOf;
-};
-/** What `step.ask` takes. */
-interface AskStepConfig<C extends string> {
-    /**
-     * The roles asked: `viewer`, `editor`, `admin` or a custom role the schema declares, as a
-     * workflow stage's `allowedRoles`. Editors and Admins when left out. People only, never an agent.
-     */
-    readonly to?: readonly string[];
-    /** The question, rendered when the step runs: text, or {@link tpl} over the event and earlier outputs. */
-    readonly question: string | AutomationTemplate;
-    /** The answers a person may give. */
-    readonly choices: readonly C[];
-    /** How long the question stays open, up to 30 days; 7 days when left out. */
-    readonly timeout?: AutomationDuration;
-    /** The answer the step continues with once the timeout falls; without one, the step fails then. */
-    readonly onTimeout?: NoInfer<C>;
-    /** The answer a pull request's Preview run and an editor's test give at once; the first choice by default. */
-    readonly sample?: NoInfer<C>;
-}
-/** What an Ask answers later steps: the choice made, and by whom, or that the timeout fell. */
-interface AskOutput<C extends string> {
-    readonly answer: C;
-    /** What the person wrote beside the choice, at most 2,000 characters. */
-    readonly note?: string;
-    /** The user who answered; absent on a timeout and a Preview's sample. */
-    readonly answeredBy?: string;
-    /** When, as ISO-8601; absent on a timeout and a Preview's sample. */
-    readonly answeredAt?: string;
-    /** Whether the step continued with `onTimeout` because nobody answered in time. */
-    readonly timedOut: boolean;
-}
-/** An approving Ask's choices, in order: a Preview's sample is the first. */
-declare const APPROVE_CHOICES: readonly ["approve", "reject"];
-type ApproveChoice = (typeof APPROVE_CHOICES)[number];
-/**
- * What an approving `step.ask` takes (REL-4154): `approve` names an earlier Agent step's proposal,
- * and the choices are `approve` and `reject`. Only members holding `to`'s roles and the authority
- * the proposal's apply needs are asked or may answer. A timeout never approves.
- */
-interface ApproveStepConfig {
-    readonly to?: readonly string[];
-    readonly question: string | AutomationTemplate;
-    /** The proposal: `<agent step>.output.proposal`. */
-    readonly approve: Ref<AutomationProposal | null>;
-    readonly timeout?: AutomationDuration;
-    /** What the step continues with once the timeout falls: only ever `reject`. */
-    readonly onTimeout?: 'reject';
-    /** What a Preview answers at once: `approve` by default. */
-    readonly sample?: ApproveChoice;
-}
-/** What became of an approved — or not — proposal, by its units. */
-interface ApproveCounts {
-    readonly applied: number;
-    readonly stale: number;
-    readonly failed: number;
-}
-/**
- * An approving Ask's output: the answer, and what became of the proposal — `applied`; `rejected`,
- * answered so or timed out; `stale`, a Record that moved since the agent read it; or `failed`.
- */
-interface ApproveOutput extends AskOutput<ApproveChoice> {
-    readonly outcome: 'applied' | 'rejected' | 'stale' | 'failed';
-    readonly counts: ApproveCounts;
-}
-/** What `steps` is handed to build steps with. */
-interface StepBuilder {
-    /** Run one of the project's Functions, taken by import, with its input. */
-    fn<F extends FunctionDefinition>(name: string, fn: F, input: StepInput<FunctionInputOf<F>>): StepWithOutput<FunctionOutputOf<F>>;
-    /**
-     * Ask an agent to read, answer the declared Fields and propose one change to the types `propose`
-     * names. Nothing it proposes is written until an Ask approves it (`step.ask(…, { approve })`).
-     */
-    agent<const O extends KeyedMembers>(name: string, config: ProposingAgentStepConfig<O>): StepWithOutput<ProposingOutput<ValuesOf$1<O>>>;
-    /** Ask an agent to read and answer the declared Fields. It reads; it never writes or sends. */
-    agent<const O extends KeyedMembers>(name: string, config: AgentStepConfig<O>): StepWithOutput<ValuesOf$1<O>>;
-    /** Send through an Extension's Action, from the events worker; Recorded in a Preview without its Connection. */
-    action<I, O>(name: string, action: AutomationAction<I, O>, input: StepInput<I>): StepWithOutput<O>;
-    /**
-     * Read one Record or entry again, as it stands now, by its uid — `found`, or not: an item deleted,
-     * never there, or a reference with no value is `{ found: false }`, never a failed step. An entry
-     * reads `published` by default, or the editor's view with `{ state: 'draft' }`. One item, never a
-     * query; unmetered.
-     *
-     * @example
-     * const recheck = step.lookup('recheck', records.order, event.record._metadata.id)
-     * step.if('still-unpaid', recheck.output.record.status.ne('paid'), { then: [remind] })
-     */
-    lookup<H extends LookupType>(name: string, type: H, uid: UidRef, options?: LookupOptions<H>): StepWithOutput<LookedUp<H>>;
-    /** Read one item, named by `<type>.ref(uid)`, again as it stands now. */
-    lookup<H extends AutomationItemHandle>(name: string, item: H, options?: LookupOptions<H>): StepWithOutput<LookedUp<H>>;
-    /** Then one step list or the other, by a condition over the event and earlier outputs. */
-    if(name: string, condition: ConditionTree, branches: {
-        readonly then?: readonly StepHandle[];
-        readonly else?: readonly StepHandle[];
-    }): StepHandle;
-    /** Hold the run, up to 30 days: `'90m'`, `'2h'`, `'3d'`. */
-    wait(name: string, duration: AutomationDuration): StepHandle;
-    /**
-     * Ask the people holding `to`'s roles, through the Studio inbox and an email, and continue with
-     * the first answer — one of `choices` — or with `onTimeout` once `timeout` falls.
-     */
-    ask<const C extends string>(name: string, config: AskStepConfig<C>): StepWithOutput<AskOutput<C>>;
-    /**
-     * Ask whether to apply an Agent step's proposal: `approve` applies it through ai-gateway's apply
-     * path as the person who answered, and the run continues once it is applied, with the outcome.
-     *
-     * @example
-     * const approval = step.ask('approve', { to: ['editor'], question: 'Publish the page?', approve: draft.output.proposal, onTimeout: 'reject' })
-     * step.if('moved', approval.output.outcome.eq('stale'), { then: [tellOps] })
-     */
-    ask(name: string, config: ApproveStepConfig): StepWithOutput<ApproveOutput>;
-}
-/** What `defineAutomation` takes. */
-interface AutomationConfig<E> {
-    readonly description?: string;
-    /**
-     * The trigger: `records.<type>.<action>(…)`, `entries.<type>.<action>(…)`, `anyEntry.<action>(…)`,
-     * `schedule.cron(…)`,
-     * `automations.runFailed(…)`, or an Extension's Trigger from `relyio/extensions.ts`.
-     */
-    readonly on: AutomationTriggerHandle<E>;
-    /**
-     * What each run is about, so the runs about one order are found across Automations: one Record or
-     * entry, by a uid the event names — `({ event }) =>
-     * records.order.ref(event.payload.data.object.metadata.orderId)`. Left out, a run is about what its
-     * trigger names: the Record or entry of a RelyIO event, the outside object of an Extension's
-     * Trigger (Stripe's payment intent), the failed run's item, or nothing for a clock.
-     */
-    readonly about?: (context: {
-        readonly event: Ref<E>;
-    }) => AutomationItemHandle;
-    /**
-     * Called once, when the Manifest loads, with a reference to the event and the step builder;
-     * returns the steps in the order a run takes them.
-     */
-    readonly steps: (context: {
-        readonly event: Ref<E>;
-        readonly step: StepBuilder;
-    }) => readonly StepHandle[];
-}
-/**
- * What an Automation file default-exports: its definition as data, each Function step still naming
- * the Function it imported. The CLI names those by their files ({@link resolveAutomation}).
- */
-interface AutomationFile {
-    readonly _tag: 'automation';
-    readonly description?: string;
-    readonly on: AutomationTrigger;
-    readonly about?: AutomationItemRef;
-    readonly steps: readonly AutomationStepDraft[];
-}
-/**
- * Declare an Automation. The file's name is its name; `relyio deploy` reads it into the Manifest,
- * plans it and ships it with the rest.
- */
-declare function defineAutomation<E>(config: AutomationConfig<E>): AutomationFile;
-/** Whether `value` is what `defineAutomation` returns: how the CLI reads an Automation file. */
-declare function isAutomationFile(value: unknown): value is AutomationFile;
-/**
- * The Automation as the Manifest carries it: each Function step's Function named by `nameOf` — the
- * CLI's, which knows which file under `relyio/functions/` exported it. A Function no file exported
- * is refused by name.
- */
-declare function resolveAutomation(file: AutomationFile, nameOf: (fn: FunctionDefinition) => string | undefined): AutomationDefinition;
-
-/**
- * `@relyio/sdk/functions` — a Function, declared (spec 2, REL-3819; ADR 0021).
- *
- * One file per Function at `relyio/functions/<name>.ts`, default-exporting what
- * {@link defineFunction} returns; the file's name is the Function's. Everything but `run` is data —
- * its input and output Fields, its reach, its Secrets and its Ways in — which `relyio deploy` reads
- * into the Manifest and plans. `run` is the code: the CLI bundles the file and uploads the bundle.
- *
- * @example
- * // relyio/functions/checkout.ts
- * import { defineFunction, fields } from '@relyio/sdk/functions'
- *
- * export default defineFunction({
- *   input: { cartId: fields.shortText({ required: true }) },
- *   output: { orderId: fields.shortText({ required: true }) },
- *   records: { read: ['cart', 'product'], write: ['order', 'inventory'] },
- *   network: [{ host: 'api.stripe.com' }],
- *   secrets: { STRIPE_SECRET_KEY: { hosts: ['api.stripe.com'] } },
- *   route: { method: 'POST', path: '/checkout' },
- *   async run({ input, records }) {
- *     const cart = await records.cart.get(input.cartId)
- *     // records.review here is a type error: checkout does not declare it
- *     …
- *   },
- * })
- *
- * **Typed from the schema.** Once `relyio generate-types` has registered the schema (`Register`), a
- * Record type the reach names must be one the schema declares, and `records.<type>` is typed by its
- * fields. A type the reach does not name is not on `records` at all.
- *
- * The capability object's runtime is the Functions runner's (spec 2, F2); this module declares its
- * types and the data `defineFunction` evaluates to.
- */
-
-/** Where a Function runs: a Dynamic Worker by default, a Container when it says so. */
-type FunctionRuntime = 'isolate' | 'container';
-/** A Container's instance type (Cloudflare's names): up to `standard-4`, 4 vCPU and 12 GiB. */
-type FunctionContainerSize = 'lite' | 'basic' | 'standard-1' | 'standard-2' | 'standard-3' | 'standard-4';
-/** A whole number of seconds or minutes: `'30s'`, `'5m'`. */
-type FunctionDuration = `${number}s` | `${number}m`;
-/** The methods a route answers. */
-type FunctionRouteMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-/** A host a Function may call. `preview: 'send'`: a Preview branch's request to it is sent, not Recorded. */
-interface FunctionNetworkHost {
-    readonly host: string;
-    readonly preview?: 'send';
-}
-/**
- * An Extension's Action a Function may send through (spec 3, REL-3856), as the declaration carries
- * it: the Extension's and the Action's catalog slugs.
- */
-interface FunctionActionReach {
-    readonly extension: string;
-    readonly action: string;
-}
-/**
- * An Action handle `reach.actions` takes: what `relyio/extensions.ts`' handles hand out
- * (`resend.send`), its Extension and Action slugs and its input and output carried as types.
- */
-type FunctionActionHandle = AutomationAction<unknown, unknown>;
-/** A Secret a Function declares: the hosts it may be sent to. Its value is set per Environment. */
-interface FunctionSecretDeclaration {
-    readonly hosts: readonly string[];
-}
-/** An HTTP route: static segments and `:params` — `'/orders/:id'`. */
-interface FunctionRoute {
-    readonly method: FunctionRouteMethod;
-    readonly path: string;
-    /** Present: a Public route on the Project's host, called without a key, 60 calls a minute per address unless `perIp` says otherwise. */
-    readonly public?: {
-        readonly perIp?: number;
-        /** A Secret this Function declares, holding the Turnstile secret key a call's token is verified with. */
-        readonly turnstile?: string;
-    };
-    /** Browser origins allowed to call the route: `['https://shop.example.com']`. */
-    readonly cors?: readonly string[];
-}
-/** An agent tool, offered in the AI Workspace and over MCP. */
-interface FunctionTool {
-    readonly description: string;
-}
-/** A schedule, to the minute, on Production only: `{ cron: '0 8 * * 1', timezone: 'Europe/Berlin' }`. */
-interface FunctionSchedule {
-    readonly cron: string;
-    readonly timezone: string;
-}
-/**
- * A stored Field, as the content model compiles a keyed one. Plain data: what the Manifest carries
- * and `@relyio/manifest` validates.
- */
-type FunctionFieldDeclaration = object;
-/**
- * What a Function declares besides its code, every default filled: the Functions area's data shape
- * (`@relyio/manifest`'s `FunctionDeclaration`, which the CLI's type test holds this to).
- */
-interface FunctionDeclaration {
-    readonly description?: string;
-    readonly runtime: FunctionRuntime;
-    readonly container?: {
-        readonly size: FunctionContainerSize;
-    };
-    readonly limits?: {
-        readonly cpu?: FunctionDuration;
-        readonly duration?: FunctionDuration;
-    };
-    readonly input: readonly FunctionFieldDeclaration[];
-    readonly output?: readonly FunctionFieldDeclaration[];
-    readonly records: {
-        readonly read: readonly string[];
-        readonly write: readonly string[];
-    };
-    readonly content: 'published' | 'none';
-    readonly network: readonly FunctionNetworkHost[];
-    readonly secrets: Readonly<Record<string, FunctionSecretDeclaration>>;
-    /** The Actions it may send (REL-3856); absent when it declares none. */
-    readonly actions?: readonly FunctionActionReach[];
-    readonly route?: FunctionRoute;
-    readonly tool?: FunctionTool;
-    readonly schedule?: FunctionSchedule;
-}
-/**
- * The Record type names a schema declares, or any name without one. Generic over the schema on
- * purpose: written over `RegisteredSchema` directly, the conditional was resolved once, before the
- * program's `Register` augmentation was in view, and answered `string` (measured).
- */
-type RecordTypeNameIn<S> = S extends AnySchemaDefinition ? SchemaRecordTypeNames<S> : string;
-/** The Record type names the registered schema declares, or any name before one is registered. */
-type FunctionRecordTypeName = RecordTypeNameIn<RegisteredSchema>;
-/** A Record type of a schema, by name. */
-type RecordTypeIn<S, K> = S extends AnySchemaDefinition ? NonNullable<S['recordTypes']>[K & keyof NonNullable<S['recordTypes']>] : never;
-/** A Record of one Record type as a read answers it, typed by the schema when there is one. */
-type RecordIn<S, K> = S extends AnySchemaDefinition ? InferRecordType<RecordTypeIn<S, K>> : BaseRecord;
-/** What a create of one Record type takes. */
-type WriteIn<S, K> = S extends AnySchemaDefinition ? RecordWriteFieldsOf<RecordTypeIn<S, K>> : Record<string, unknown>;
-/** What an update of one Record type takes: the create's values without its Counters. */
-type UpdateIn<S, K> = S extends AnySchemaDefinition ? RecordUpdateFieldsOf<RecordTypeIn<S, K>> : Record<string, unknown>;
-/** A Record of one Record type of the registered schema. */
-type RecordOf<K> = RecordIn<RegisteredSchema, K>;
-/**
- * A File a run sets (REL-3832), as `records.file(bytes, { name })` answers it: its name, media type
- * and size, and the bytes held beside it until the write naming it is sent. Set it as the value of
- * a File field in a create, an update or a batch; the run asks RelyIO for the upload, puts the bytes
- * and sends the write naming it, so a retried run names the File its first attempt stored.
- */
-interface FunctionFile {
-    readonly name: string;
-    /** The media type: as given, else read off the name's extension, else `application/octet-stream`. */
-    readonly type: string;
-    /** In bytes. */
-    readonly size: number;
-}
-/** What a write takes: a File field takes a {@link FunctionFile} where it takes an upload. */
-type WithFunctionFiles<T> = {
-    [F in keyof T]: FileUpload extends NonNullable<T[F]> ? T[F] | FunctionFile : T[F];
-};
-/** A Counter move in a run: the Record by `id`, `where` or both, the Counter, and how far. */
-type FunctionCounterMove = RecordBatchTarget & {
-    readonly field: string;
-    /** A whole number above zero. */
-    readonly by: number;
-};
-/**
- * What a run may do with a Record type it only reads (REL-3822), on the run's Dataset, through spec
- * 1's Record reader. `get` answers `null` for a Record not stored. A Record type the reach does not
- * name is refused at run time too, not only by these types.
- */
-interface FunctionRecordReader<K> {
-    get(id: string): Promise<RecordOf<K> | null>;
-    list(options?: {
-        /** Field conditions, in the grammar `relyio.records(type).list({ where })` takes. */
-        where?: Record<string, unknown>;
-        /** One key and its direction: `createdAt:desc` when absent. */
-        sort?: `${string}:${'asc' | 'desc'}`;
-        /** At most 100. */
-        limit?: number;
-        cursor?: string;
-    }): Promise<{
-        data: RecordOf<K>[];
-        page: {
-            nextCursor: string | null;
-            hasMore: boolean;
-        };
-    }>;
-    count(options?: {
-        where?: Record<string, unknown>;
-    }): Promise<number>;
-}
-/**
- * What a run may do with a Record type it writes: read it, and write it one operation at a time —
- * each sent as a batch of one, keyed as every batch of the run is, so a retried run writes it once.
- * A refusal throws {@link FunctionBatchRefused} naming operation 0.
- */
-interface FunctionRecordWriter<K> extends FunctionRecordReader<K> {
-    create(fields: WithFunctionFiles<WriteIn<RegisteredSchema, K>>): Promise<RecordOf<K>>;
-    update(id: string, fields: {
-        [F in keyof UpdateIn<RegisteredSchema, K>]?: WithFunctionFiles<UpdateIn<RegisteredSchema, K>>[F] | null;
-    }, options?: {
-        revision?: number;
-    }): Promise<RecordOf<K>>;
-    delete(id: string): Promise<void>;
-    increment(move: FunctionCounterMove): Promise<RecordOf<K>>;
-    decrement(move: FunctionCounterMove): Promise<RecordOf<K>>;
-}
-/**
- * The synchronous collector `records.batch` hands its callback: each call adds one operation, over
- * the Record types the Function writes, and nothing is read inside it. The batch is sent once the
- * callback returns — all or none. Each answers `undefined`, and the callback must too: one that
- * awaits returns a promise, which is a type error here and refused at run time.
- */
-interface FunctionRecordBatch<W extends string> {
-    create(type: W, fields: Record<string, unknown>): undefined;
-    update(type: W, target: RecordBatchTarget & {
-        fields: Record<string, unknown>;
-        revision?: number;
-    }): undefined;
-    delete(type: W, target: RecordBatchTarget): undefined;
-    increment(type: W, move: FunctionCounterMove): undefined;
-    decrement(type: W, move: FunctionCounterMove): undefined;
-}
-/** What a committed batch answers: the Records it created, in order, and every operation's outcome. */
-type FunctionBatchResult = RecordBatchResult & {
-    /** The Records its creates stored, in the order the batch sent them. */
-    readonly created: BaseRecord[];
-};
-/**
- * What a refused batch throws in a run (REL-3822), a one-operation write's included: nothing of the
- * batch was written. `operation` is the refused operation's index from 0, `code` the API's code
- * (`RESOURCE_CONFLICT`, `CONTENT_INVALID`, `ACCESS_DENIED`, …), `reason` what it named — a
- * blockage's kind such as `counter-out-of-bounds`, or an issue's code — and `field` the Record field
- * it is about, when it names one: which line of a checkout ran out of stock.
- */
-interface FunctionBatchRefused extends Error {
-    readonly name: 'BatchRefused';
-    readonly operation: number | null;
-    readonly code: string;
-    readonly reason: string | null;
-    readonly field: string | null;
-    readonly details: Readonly<Record<string, unknown>>;
-}
-/** Whether `error` is a run's refused batch — what `records.batch` and every single write throw. */
-declare function isBatchRefused(error: unknown): error is FunctionBatchRefused;
-/** `records` in a run: exactly the Record types the reach names, and a batch over those it writes. */
-type FunctionRecords<R extends string, W extends string> = {
-    readonly [K in R | W]: K extends W ? FunctionRecordWriter<K> : FunctionRecordReader<K>;
-} & {
-    batch(collect: (batch: FunctionRecordBatch<W>) => undefined): Promise<FunctionBatchResult>;
-    /**
-     * A File for a File field of a Record type the Function writes (REL-3832): the bytes and the
-     * name, and the media type when the name's extension does not say it. Answers at once — inside a
-     * batch's collector too — and is set by the write that names it.
-     */
-    file(bytes: Uint8Array | ArrayBuffer, options: {
-        readonly name: string;
-        readonly type?: string;
-    }): FunctionFile;
-};
-/**
- * Which Way in started a run, or `editor`: a test run from the Function editor, which always runs in
- * the person's own Preview branch.
- */
-type FunctionWayIn = 'sdk' | 'route' | 'tool' | 'schedule' | 'automation' | 'editor';
-/** What a run knows of itself: its id survives every retry. */
-interface FunctionRunInfo {
-    readonly id: string;
-    readonly attempt: number;
-    readonly wayIn: FunctionWayIn;
-    /**
-     * Who called, as the run record names them: `api-key:<keyId>`, `task:<taskId>` for a scheduled or
-     * Automation run, or `user:<userId>` for a person's tool call or test run.
-     */
-    readonly caller: string;
-    readonly environment: 'production' | 'preview';
-    /**
-     * The Branch the run runs on (spec 3, REL-3853): what a checkout hands Stripe as
-     * `metadata.relyio_branch`, so a Preview payment's events run that Branch's Automations.
-     */
-    readonly branchId: string;
-    /**
-     * What started a run no request started: a schedule's firing — `{ type: 'function.schedule',
-     * scheduledFor }`, the UTC instant it was for — or the event an Automation step reacts to.
-     * Absent from a run an SDK call, a route or a tool started.
-     */
-    readonly event?: Readonly<Record<string, unknown>>;
-}
-/** Published content, read through the read core: present when the reach declares `content: 'published'`. */
-interface FunctionContent {
-    get(type: string, id: string): Promise<Record<string, unknown> | null>;
-    list(type: string, options?: {
-        where?: Record<string, RecordConditionValue>;
-        limit?: number;
-    }): Promise<{
-        data: Record<string, unknown>[];
-    }>;
-}
-/** A Function's input or output values, as its Fields declare them. */
-type ValuesOf<F extends KeyedMembers> = FieldValues<DeclaredFields<{
-    readonly fields: readonly KeyedMembersOf<F>[];
-}>>;
-/** What one Action handle's call takes and answers. */
-type ActionCallOf<H> = H extends AutomationAction<infer I, infer O, string, string> ? (input: I) => Promise<O> : never;
-/**
- * `actions` in a run (REL-3856): `actions.<extension>.<action>(input)` for exactly the Actions the
- * reach declares, typed by the Extension's own declaration. A call is sent through the events
- * worker's one send point with the run's Environment — the run holds no key — and answers the
- * Action's result; in a Preview without a Preview Connection, the Action's sample, the call Recorded
- * on the run. A refusal throws {@link FunctionActionRefused}.
- */
-type FunctionActions<A extends FunctionActionHandle> = {
-    readonly [E in A['extension']]: {
-        readonly [N in Extract<A, {
-            readonly extension: E;
-        }>['action']]: ActionCallOf<Extract<A, {
-            readonly extension: E;
-            readonly action: N;
-        }>>;
-    };
-};
-/**
- * What a refused Action call throws in a run (REL-3856): nothing stands sent. `code` names why —
- * `extension-not-connected` (the Extension has no Connection in the run's Environment: Functions are
- * never paused, their call fails), `action-input-invalid`, `action-send-failed`, or the API's own
- * (`ACCESS_DENIED` for an Action outside the reach) — and `retryable` whether another attempt could
- * send it.
- */
-interface FunctionActionRefused extends Error {
-    readonly name: 'ActionRefused';
-    readonly code: string;
-    readonly retryable: boolean;
-    readonly extension: string;
-    readonly action: string;
-}
-/** Whether `error` is a run's refused Action call. */
-declare function isActionRefused(error: unknown): error is FunctionActionRefused;
-/** Everything a run is handed (spec 2, "The capability object"). No key, no project id. */
-interface FunctionCapabilities<I extends KeyedMembers, R extends string, W extends string, C extends 'published' | 'none', S extends string, A extends FunctionActionHandle = never> {
-    readonly input: ValuesOf<I>;
-    readonly records: FunctionRecords<R, W>;
-    /** The Actions the reach declares, each sent without the run holding its key (REL-3856). */
-    readonly actions: FunctionActions<A>;
-    /** Published entries; `undefined` unless the reach declares `content: 'published'`. */
-    readonly content: C extends 'published' ? FunctionContent : undefined;
-    /** The gateway's fetch: only the hosts the reach declares answer. */
-    readonly fetch: typeof globalThis.fetch;
-    /** Each declared Secret as a placeholder the gateway swaps for its value on the way to its hosts. */
-    readonly secrets: {
-        readonly [K in S]: string;
-    };
-    readonly run: FunctionRunInfo;
-    /** The HTTP request, for a run a route started. */
-    readonly request: Request | undefined;
-}
-/**
- * A response a route Function shapes itself (REL-3829): return `respond({ … })` from `run` and the
- * route answers with that status, those headers and that body — a redirect after a form post, a
- * `201`, a webhook's plain-text `ok`. A string body is sent as it is; any other value as JSON;
- * `null` or none sends no body. Any other output a route Function returns is answered as JSON with
- * `200`. The hop's own headers (`content-length`, `transfer-encoding`, …) are RelyIO's to set.
- */
-interface FunctionResponse {
-    readonly _tag: 'function-response';
-    readonly status: number;
-    readonly headers: Readonly<Record<string, string>>;
-    readonly body: unknown;
-}
-/**
- * Shape a route Function's response.
- *
- * @example
- * return respond({ status: 303, headers: { location: 'https://acme.example/thanks' } })
- */
-declare function respond(response: {
-    /** 200–599. */
-    readonly status: number;
-    readonly headers?: Readonly<Record<string, string>>;
-    readonly body?: unknown;
-}): FunctionResponse;
-/** What `defineFunction` takes. Every part but `run` is data. */
-interface FunctionConfig<I extends KeyedMembers, O extends KeyedMembers, R extends FunctionRecordTypeName, W extends FunctionRecordTypeName, C extends 'published' | 'none', S extends string, A extends FunctionActionHandle = never> {
-    description?: string;
-    /** `'isolate'` when left out. */
-    runtime?: FunctionRuntime;
-    container?: {
-        size: FunctionContainerSize;
-    };
-    limits?: {
-        cpu?: FunctionDuration;
-        duration?: FunctionDuration;
-    };
-    /** The input's Fields, under their ids, as the content model's `fields.*` write them. */
-    input?: I;
-    output?: O;
-    /** Reach: the Record types it reads and writes, by name. None when left out. */
-    records?: {
-        read?: readonly R[];
-        write?: readonly W[];
-    };
-    /** Reach: `'published'` to read published content. `'none'` when left out. */
-    content?: C;
-    /** Reach: the hosts it calls. None when left out. */
-    network?: readonly FunctionNetworkHost[];
-    secrets?: {
-        readonly [K in S]: FunctionSecretDeclaration;
-    };
-    /**
-     * Reach: the Extensions' Actions it may send, by the handles `relyio/extensions.ts` gives —
-     * `actions: [resend.send]`. None when left out; `actions.<extension>.<action>` for any other is a
-     * type error, and refused at run time.
-     */
-    actions?: readonly A[];
-    route?: FunctionRoute;
-    tool?: FunctionTool;
-    schedule?: FunctionSchedule;
-    run(capabilities: FunctionCapabilities<I, R, W, C, S, A>): Promise<ValuesOf<O> | FunctionResponse | void> | ValuesOf<O> | FunctionResponse | void;
-}
-/** Where a Function's input and output types ride on its definition, for the compiler alone. */
-declare const FUNCTION_FIELDS: unique symbol;
-/**
- * What a Function file default-exports: its declaration as data, and its code. `I` and `O` are its
- * input and output Fields, carried for the compiler alone, so an Automation's Function step that
- * takes it by import types its input and its output from them (spec 3, REL-3845).
- */
-interface FunctionDefinition<I extends KeyedMembers = KeyedMembers, O extends KeyedMembers = KeyedMembers> {
-    readonly _tag: 'function';
-    readonly declaration: FunctionDeclaration;
-    readonly run: (capabilities: never) => unknown;
-    /** Never present at run time: the input and output Fields, as types. */
-    readonly [FUNCTION_FIELDS]?: {
-        readonly input: I;
-        readonly output: O;
-    };
-}
-/** A Function's input values, as its Fields declare them. */
-type FunctionInputOf<F> = F extends FunctionDefinition<infer I, KeyedMembers> ? ValuesOf<I> : never;
-/** A Function's output values, as its Fields declare them. */
-type FunctionOutputOf<F> = F extends FunctionDefinition<KeyedMembers, infer O> ? ValuesOf<O> : never;
-/**
- * Declare a Function. The file's name is its name; `relyio deploy` reads the declaration, bundles the
- * file and ships both with the schema.
- */
-declare function defineFunction<const I extends KeyedMembers = Record<never, never>, const O extends KeyedMembers = Record<never, never>, const R extends FunctionRecordTypeName = never, const W extends FunctionRecordTypeName = never, const C extends 'published' | 'none' = 'none', const S extends string = never, const A extends FunctionActionHandle = never>(config: FunctionConfig<I, O, R, W, C, S, A>): FunctionDefinition<I, O>;
-/** Whether `value` is what `defineFunction` returns: how the CLI reads a Function file's default export. */
-declare function isFunctionDefinition(value: unknown): value is FunctionDefinition;
-
-export { type FunctionActionRefused as A, type Accepts, type AgentStepConfig, type AnyEntryEvent, type AnyEntryTriggers, type ApproveCounts, type ApproveOutput, type ApproveStepConfig, type AskOutput, type AskStepConfig, type AutomationAction, type AutomationBecomesTest, type AutomationConfig, type AutomationDefinition, type AutomationDuration, type AutomationEntryAction, type AutomationFile, type AutomationInput, type AutomationItemHandle, type AutomationItemRef, type AutomationJson, type AutomationLookupState, type AutomationProposal, type AutomationProposeTarget, type AutomationRecordAction, type AutomationRef, type AutomationStep, type AutomationStepDraft, type AutomationTemplate, type AutomationTrigger, type AutomationTriggerHandle, type AutomationValue, type AutomationWhere, isActionRefused as B, type FunctionCapabilities as C, type FunctionResponse as D, respond as E, type EntryEvent, type EntryTriggers, type ExtensionTriggerEvent, type FunctionRuntime as F, type FunctionConfig as G, type FunctionDefinition as H, type FunctionInputOf as I, type FunctionOutputOf as J, defineFunction as K, isFunctionDefinition as L, type LookedUp, type LookedUpEntry, type LookedUpEntryItem, type LookedUpRecord, type LookupOptions, type ProposingAgentStepConfig, type ProposingOutput, type RecordEvent, type RecordTriggers, type Ref, type RunFailedEvent, type RunFailedWhere, type StepBuilder, type StepHandle, type StepInput, type StepWithOutput, type TriggerWhere, type UidRef, type FunctionContainerSize as a, and, anyEntry, automations, type FunctionDuration as b, type FunctionRouteMethod as c, type FunctionNetworkHost as d, defineAutomation, type FunctionActionReach as e, entries, extensionTrigger, type FunctionActionHandle as f, type FunctionSecretDeclaration as g, type FunctionRoute as h, type FunctionTool as i, isAutomationFile, type FunctionSchedule as j, type FunctionFieldDeclaration as k, type FunctionDeclaration as l, type FunctionRecordTypeName as m, type FunctionFile as n, not, type FunctionCounterMove as o, on, or, type FunctionRecordReader as p, type FunctionRecordWriter as q, type FunctionRecordBatch as r, records, resolveAutomation, type FunctionBatchResult as s, schedule, type FunctionBatchRefused as t, tpl, isBatchRefused as u, type FunctionRecords as v, type FunctionWayIn as w, type FunctionRunInfo as x, type FunctionContent as y, type FunctionActions as z };