@drhomet/mithaq 0.0.0-stage → 0.1.1

package/dist/asas/runner/steps.d.ts

@@ -0,0 +1,400 @@
+import type { StandardSchemaIssue, StandardSchemaV1 } from '../../mithaq/standard-schema.ts';
+import type { BoundOf } from './write.ts';
+import type { Where } from '../../mithaq/where.ts';
+import type { ResolvedKayan, RuntimeField, ServiceOf } from '../../mithaq/types.ts';
+import type { Store } from '../../mithaq/language.ts';
+/**
+ * What the caller passed, plus the three keys the runner keeps. `Extra` is the service target's
+ * `context`, so a project reads its own keys typed. Held in an `AsyncLocalStorage`, so nested writes are counted.
+ */
+export type Context<Extra extends Record<string, unknown> = Record<string, unknown>> = {
+    /** How many writes deep this one is. The runner raises it by one. */
+    depth: number;
+    /** What started the write. A call in the app is `local`. */
+    source: string;
+    /** `${kayan}.${operation}` per write, so one past the cap can name its way in. */
+    chain: string[];
+} & Extra;
+/** What a step is handed. No `db`: a step writes through `ctx.tx`, so it cannot land outside the list's transaction. */
+export type Ctx<Data = Record<string, unknown>, Actor = unknown, Tx = unknown, Extra extends Record<string, unknown> = Record<string, unknown>> = {
+    kayan: ResolvedKayan;
+    /** The write's values, and after the store step the row that was written. */
+    data: Data;
+    /** Whoever the write was given, or null. */
+    actor: Actor;
+    /** Same user as `actor`, named like access callbacks. */
+    user: Actor;
+    /** The row loaded before an update or delete; `undefined` in `beforeTransaction`, which runs before the load. */
+    dataBefore?: Readonly<Record<string, unknown>>;
+    /** The persisted row currently known to the runner. */
+    dataAfter?: Readonly<Record<string, unknown>>;
+    /** The store's transaction. Every write in the list goes through it. */
+    tx: Tx;
+    context: Context<Extra>;
+};
+/** The keys the project put on the service target's `context`, or the open record where it put none. */
+export type ContextOf<Service> = Service extends {
+    context: infer Extra extends Record<string, unknown>;
+} ? Extra : Record<string, unknown>;
+/** What a step of this project is handed: `Ctx` with the project's context filled in. */
+export type CtxOf<Service, Data = Record<string, unknown>, Actor = unknown, Tx = unknown> = Ctx<Data, Actor, Tx, ContextOf<Service>>;
+/** The audit sink the `audit` step calls before commit. */
+export type AuditHandler<Actor = unknown, Tx = unknown> = (entry: {
+    context: Context;
+    effect: OperationEffect;
+    kayan: ResolvedKayan;
+    operation: string;
+    dataBefore?: Readonly<Record<string, unknown>>;
+    dataAfter: unknown;
+    store?: Pick<Store, 'insert' | 'remove' | 'update'>;
+    tx?: Tx;
+    user: Actor | null;
+}) => void | Promise<void>;
+export type CommonTools<Kayans = unknown, Actor = unknown, Tx = unknown> = {
+    /** The key this list sits under in the `operations` record. */
+    operation: string;
+    /** The shape this operation parses against: its validate function's, or the derived one. */
+    schema: StandardSchemaV1;
+    /** Final row boundary, applied after every step so public row types are proved. */
+    output: StandardSchemaV1;
+    /** Custom output schemas are public contracts and run after masking. */
+    publicOutput?: StandardSchemaV1;
+    /** Managed nested calls bound to the runner's current user, context and transaction. */
+    kayans: Kayans;
+    /** Optional audit sink configured on the service target. */
+    audit?: AuditHandler<Actor, Tx>;
+    /** Every permission key this project has, as `asas.catalog` publishes it; empty where none was handed over, which refuses every key. */
+    catalog: readonly string[];
+};
+/** What a read step can do: run the managed read fetcher. No write store exists. */
+export type ReadTools<Kayans = unknown, Actor = unknown, Tx = unknown> = CommonTools<Kayans, Actor, Tx> & {
+    /** The public access callback this operation uses. */
+    effect: 'read';
+    /** What the list's managed read step does: one row, or a page of them. */
+    kind: ReadMode;
+    /** Managed read fetcher, present only for read steps. */
+    read: (data: unknown) => Promise<unknown>;
+    /** One kayan's read operations out of `kayans`, found by the declaration rather than by its name. */
+    of: BoundOf<'read'>;
+};
+/** What a write step can do: call the protected writes already bound to a transaction. */
+export type WriteTools<Kayans = unknown, Actor = unknown, Tx = unknown> = CommonTools<Kayans, Actor, Tx> & {
+    /** The public access callback this operation uses. */
+    effect: Exclude<OperationEffect, 'read'>;
+    /** What the list's store step does. A bulk word means `bulk` runs the list. */
+    kind: 'deleteMany' | 'insert' | 'remove' | 'update' | 'updateMany';
+    /** One kayan's bound operations, found and typed by the declaration handed in, so a step imports the kayan it calls. */
+    of: BoundOf<'write'>;
+    /** The store's three writes, each bound, and the store itself is not here. */
+    store: Pick<Store, 'insert' | 'remove' | 'update'>;
+    /** Access constraint already granted for this operation, if access returned one. */
+    where?: Where;
+    /** The keys the caller's own object carried, read before any step ran, so validation can tell the runner's values from the caller's. */
+    sent?: readonly string[];
+    /** The shape a global's update parses against when there is no row yet, and a publish of a never-published row. */
+    insertSchema?: StandardSchemaV1;
+    /** The shape a draft save parses against and a draft is read back through: every field's kind, nullable and optional, no rules. */
+    draftSchema?: StandardSchemaV1;
+    /** The draft save's shape where it differs from `draftSchema`: a kind may check a written value harder than a stored one. */
+    draftWrite?: StandardSchemaV1;
+    /** What a draft save of an insert with its own `input` parses against: that input over the draft shape. */
+    draftInput?: StandardSchemaV1;
+    /** Runs the single-row write once per row the `where` matched, in this transaction; present only for a bulk list. */
+    many?: (data: Record<string, unknown>) => Promise<BulkResult>;
+};
+/**
+ * What a bulk operation answers. All or nothing in one transaction, so no row is in `errors` because
+ * its write failed; `errors` lists the unpublished rows the `where` names, for an actor who may read drafts.
+ */
+export type BulkResult<Doc = Record<string, unknown>> = {
+    docs: Doc[];
+    errors: {
+        id: unknown;
+        message: string;
+    }[];
+};
+export type Tools = ReadTools | WriteTools;
+/** The positions `resolve` checks: the store and read steps, each named after the `Store` method it calls. */
+export type Seal = 'audit' | 'count' | 'defaults' | 'deleteMany' | 'find' | 'findOne' | 'insert' | 'remove' | 'update' | 'updateMany' | 'validate' | 'findVersions' | 'findVersionByID' | 'restoreVersion';
+type Holds<Name extends Seal> = {
+    readonly __seal: Name;
+};
+type AnyStep<Input extends Record<string, unknown> = Record<string, unknown>, Output extends Record<string, unknown> = Input, Actor = unknown, Tx = unknown, GivenTools = Tools, Extra extends Record<string, unknown> = Record<string, unknown>> = {
+    (ctx: Ctx<Input, Actor, Tx, Extra>, tools: GivenTools): Ctx<Output, Actor, Tx> | Promise<Ctx<Output, Actor, Tx>>;
+};
+export type CommonStep<Input extends Record<string, unknown> = Record<string, unknown>, Output extends Record<string, unknown> = Input, Actor = unknown, Tx = unknown, Kayans = unknown, Extra extends Record<string, unknown> = Record<string, unknown>> = AnyStep<Input, Output, Actor, Tx, ReadTools<Kayans, Actor, Tx> | WriteTools<Kayans, Actor, Tx>, Extra>;
+export type ReadStep<Input extends Record<string, unknown> = Record<string, unknown>, Output extends Record<string, unknown> = Input, Actor = unknown, Tx = unknown, Kayans = unknown, Extra extends Record<string, unknown> = Record<string, unknown>> = AnyStep<Input, Output, Actor, Tx, ReadTools<Kayans, Actor, Tx>, Extra>;
+export type WriteStep<Input extends Record<string, unknown> = Record<string, unknown>, Output extends Record<string, unknown> = Input, Actor = unknown, Tx = unknown, Kayans = unknown, Extra extends Record<string, unknown> = Record<string, unknown>> = AnyStep<Input, Output, Actor, Tx, WriteTools<Kayans, Actor, Tx>, Extra>;
+export type Step<Input extends Record<string, unknown> = Record<string, unknown>, Output extends Record<string, unknown> = Input, Actor = unknown, Tx = unknown, Kayans = unknown, Extra extends Record<string, unknown> = Record<string, unknown>> = CommonStep<Input, Output, Actor, Tx, Kayans, Extra>;
+/** Any of the three, at one context. `never` is the bound a resolved list is stored at, which every project's list fits. */
+export type OperationStep<Extra extends Record<string, unknown> = Record<string, unknown>> = Step<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Extra> | ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Extra> | WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Extra>;
+/** The six shapes a schema target derives from a kayan's fields, each a Standard Schema. */
+export type DerivedShapes<Schema extends StandardSchemaV1 = StandardSchemaV1> = {
+    /** Every field, with the id optional: what a list that makes the row parses. */
+    create: Schema;
+    /** The same shape partial, with the id required: what a list that finds it parses. */
+    update: Schema;
+    /** The id alone and no other key: what `delete` parses, and what a version is addressed by. */
+    id: Schema;
+    /** The `id` shape with an optional `depth`: what `findByID` parses. */
+    byID: Schema;
+    /** The row that comes back, every column present. */
+    row: Schema;
+    /** What a list read or a bulk with no schema of its own parses: the page query and a bulk's `data`. */
+    list: Schema;
+    /** What a draft save parses and a draft is read back through: every field's kind alone, nullable and optional. */
+    draft?: Schema;
+    /** What a draft save parses where it differs from `draft`: each kind checks a written value as a write does. */
+    draftWrite?: Schema;
+};
+/**
+ * One schema target's derivation as a type: a target extends this with `shapes` reading `FieldsOf<this>`.
+ * Needed because a conditional type cannot instantiate `derive`'s generic signature.
+ */
+export interface Derives {
+    /** One kayan's fields, `unknown` so filling it in replaces rather than narrows it. */
+    readonly fields: unknown;
+    /** The six shapes that target derives from them. */
+    readonly shapes: DerivedShapes;
+}
+/** The fields a target reads off itself, at the constraint every field record has. */
+export type FieldsOf<Of extends Derives> = Extract<Of['fields'], Record<string, RuntimeField>>;
+/** The shapes one schema target returns for one kayan's fields, typed by that target. */
+export type DerivedSchemas<Schema = unknown, Fields extends Record<string, RuntimeField> = Record<string, RuntimeField>> = Schema extends {
+    derives?: infer Of extends Derives;
+} ? (Of & {
+    readonly fields: Fields;
+})['shapes'] : DerivedShapes;
+/** The shapes the language's own schema target derives. */
+export type SchemasOf<L, Fields extends Record<string, RuntimeField> = Record<string, RuntimeField>> = L extends {
+    targets: infer Targets;
+} ? ServiceOf<L> extends {
+    schema: infer Name;
+} ? Name extends keyof Targets ? DerivedSchemas<Targets[Name], Fields> : DerivedShapes : DerivedShapes : DerivedShapes;
+export type OperationEffect = 'create' | 'read' | 'update' | 'delete';
+/** What a managed read returns: one row, a page, `{ totalDocs }`, or one version or a page of them. */
+export type ReadMode = 'count' | 'many' | 'one' | 'version' | 'versions';
+type RowOutput = StandardSchemaV1<unknown, Record<string, unknown>>;
+/** A list of all read steps or all write steps; a mixed one is refused where it is written. */
+export type OperationSteps<Data extends Record<string, unknown> = Record<string, unknown>, Extra extends Record<string, unknown> = Record<string, unknown>> = readonly ReadStep<Data, Record<string, unknown>, unknown, unknown, unknown, Extra>[] | readonly WriteStep<Data, Record<string, unknown>, unknown, unknown, unknown, Extra>[];
+export declare const atEffect: <Held extends OperationStep<never>>(list: readonly OperationStep<never>[]) => readonly Held[];
+/** The lists a steps function is handed, one per operation the language has. */
+export type Lists = Record<string, OperationSteps>;
+/** The steps of one declaration, whether it was written as a list or as a function. */
+export type StepsOf<Declaration> = Declaration extends {
+    steps: infer Given;
+} ? Given extends (...args: never[]) => infer Returned ? Returned : Given : never;
+/**
+ * What a steps or operations function is handed: the shipped lists by operation name, the sealed steps
+ * by `Store` method, and the service target's three slots: `afterSteps: ({ afterSteps }) => [...afterSteps, notify]`.
+ */
+export type OperationDefaults<Given = Lists> = {
+    operations: Given;
+    steps: Sealed;
+    beforeSteps: readonly CommonStep[];
+    afterSteps: readonly CommonStep[];
+    afterCommit: readonly CommonStep[];
+};
+/** One of the three lists an operation may write beside `steps`, at the project's context. */
+export type SlotSteps<Given = Lists, Extra extends Record<string, unknown> = Record<string, unknown>> = OperationSteps<Record<string, unknown>, Extra> | ((defaults: OperationDefaults<Given>) => OperationSteps<Record<string, unknown>, Extra>);
+/** An operation: data, or a function of the defaults that returns data, run once where it is declared. */
+export type OperationDeclaration<Given = Lists, Schemas = DerivedShapes, Locale extends string = string, Input = never, 
+/** What this operation parses, which is `ctx.data` in every step. */
+Data extends Record<string, unknown> = Record<string, unknown>, 
+/** The keys the project declared on its runner's `context`. */
+Extra extends Record<string, unknown> = Record<string, unknown>> = {
+    /** The shape this operation parses, once, before the first step. Without it, the shape its store or read step implies. */
+    input?: (schemas: Schemas) => StandardSchemaV1;
+    /** The list: exactly one store or managed read step and whatever surrounds it. `defaults`, `validate` and `audit` here are refused. */
+    steps: OperationSteps<Data, Extra> | ((defaults: OperationDefaults<Given>) => OperationSteps<Data, Extra>);
+    /** Outside the transaction, before it opens: no lock is held and `ctx.dataBefore` is `undefined`. Not on a read. */
+    beforeTransaction?: SlotSteps<Given, Extra>;
+    /** Inside the transaction after the list, where `audit` runs. Replaces the service target's for this operation. */
+    afterSteps?: SlotSteps<Given, Extra>;
+    /** Outside the transaction, after the commit, where a webhook or an email belongs. A throw leaves the write standing and answers `AfterCommitError`. */
+    afterCommit?: SlotSteps<Given, Extra>;
+    /** A public output contract, parsed after field masking. */
+    output?: RowOutput | ((schemas: Schemas) => RowOutput);
+    /** One entry per target with something to say about this operation, by the target's name: `targets.<screen>` is what that screen's button asks for. */
+    targets?: Readonly<Record<string, OperationScreen<Input> | undefined>>;
+};
+/** What a screen's button over one of a kayan's own operations asks for. */
+export type OperationScreen<Input = RuntimeField> = {
+    /**
+     * What the button's dialog asks for beyond the row's id, as fields. Chrome, not the contract:
+     * `input` stays the shape; a field it names no key for fails the build.
+     */
+    readonly fields?: Readonly<Record<string, Input>>;
+};
+/** A declaration whatever lists its steps function was typed against. */
+export type AnyOperation = {
+    input?: (schemas: never) => StandardSchemaV1;
+    steps: OperationSteps<never, never> | ((defaults: never) => OperationSteps<never, never>);
+    /** The three slots at the same bound `steps` above is held at, and for the same reason. */
+    beforeTransaction?: OperationSteps<never, never> | ((defaults: never) => OperationSteps<never, never>);
+    afterSteps?: OperationSteps<never, never> | ((defaults: never) => OperationSteps<never, never>);
+    afterCommit?: OperationSteps<never, never> | ((defaults: never) => OperationSteps<never, never>);
+    output?: RowOutput | ((schemas: never) => RowOutput);
+    targets?: Readonly<Record<string, OperationScreen | undefined>>;
+};
+export type Operations<Given = Lists, Schemas = DerivedShapes, Locale extends string = string, Input = never> = {
+    [operation: string]: OperationDeclaration<Given, Schemas, Locale, Input> | undefined;
+};
+/** An operation after `resolve` has run its steps function and read its effect. */
+export type ResolvedOperation = {
+    /** The shape function this operation named, held until `build` has the derived shapes. */
+    input?: (schemas: never) => StandardSchemaV1;
+    /** The lists, at the context bound every project's own is inside. */
+    steps: readonly OperationStep<never>[];
+    /** The four lists around the steps, each already merged with the language's. */
+    beforeTransaction: readonly OperationStep<never>[];
+    beforeSteps: readonly OperationStep<never>[];
+    afterSteps: readonly OperationStep<never>[];
+    afterCommit: readonly OperationStep<never>[];
+    effect: OperationEffect;
+    mode?: ReadMode;
+    /** Always a schema: an `output` written as a function is resolved at build. */
+    output?: RowOutput;
+    /** What each target says about this operation, as the declaration wrote it. */
+    targets?: Readonly<Record<string, OperationScreen | undefined>>;
+};
+/** What position this step holds, or nothing at all for a step of the app's own. */
+export declare const sealOf: (step: OperationStep<never>) => Seal | undefined;
+/** Hold an operation's `output` function until `build` has the derived shapes. */
+export declare const holdOutput: (operation: ResolvedOperation, of: (schemas: never) => RowOutput) => void;
+/** The schema function this operation's `output` carries, or nothing for a bare schema. */
+export declare const outputOf: (operation: ResolvedOperation) => ((schemas: never) => RowOutput) | undefined;
+/** The list's store step, the one that makes, changes or removes the row. */
+export declare const storeSeals: readonly Seal[];
+export declare const readSeals: readonly Seal[];
+export declare const bulkSeals: readonly Seal[];
+export declare const versionSeals: readonly Seal[];
+/** The read no actor holds, which a secret column carries. One function, so a column is known by it. */
+export declare const neverRead: () => boolean;
+/**
+ * The audit step a project lists in the service target's `afterSteps`. A step after the store
+ * that changes persistence must return the persisted row in `ctx.data`. Listing it without a sink fails the build.
+ */
+export declare const audit: CommonStep & Holds<'audit'>;
+/**
+ * Fills what the write left out. On a list that only changes a row only `nowOnUpdate` fields
+ * are filled, or `createdAt` would take the edit's moment. The runner runs it; a list naming it is refused.
+ */
+export declare const defaults: WriteStep & Holds<'defaults'>;
+/** The refusal a list of Standard Schema issues becomes, shared by the parse and the oRPC boundary so every 400 has one shape. */
+export declare const issueRefusal: (issues: readonly StandardSchemaIssue[], vendor?: string) => import("./errors.ts").AsasError;
+/** A plain object copied without a prototype, because zod reads an unsent key off the prototype. */
+export declare const withoutPrototype: (value: unknown) => any;
+/** Validates through Standard Schema's own `validate`, sync or async, never one library's `parse`. */
+export declare const validated: (schema: StandardSchemaV1, value: unknown) => Promise<unknown>;
+/**
+ * The runner's parse. A field the client does not supply is absent from the wire shape, so a value the
+ * runner put there is set aside, the rest parsed, and the set-aside values put back. `id` is never set aside.
+ */
+export declare const parse: ({ schema, ctx, tools }: {
+    schema: StandardSchemaV1;
+    ctx: Ctx;
+    tools: ParseTools;
+}) => Promise<Ctx>;
+export type ParseTools = Pick<CommonTools, 'schema'> & Partial<Pick<WriteTools, 'sent'>> & {
+    kind?: ReadMode | WriteTools['kind'];
+};
+/** A marker, refused by name in a list: the parse is the runner's own. The shape it carried is the operation's `input`. */
+export declare const validate: CommonStep & Holds<'validate'> & ((of?: unknown) => CommonStep);
+/** Make the row, and what came back is what the rest of the list sees. */
+export declare const insert: WriteStep & Holds<'insert'>;
+/** Change the one row the id names; everything else in `data` is the change. An id alone is refused with a 400. */
+export declare const update: WriteStep & Holds<'update'>;
+/** Remove the one row the id names, and hand back what was removed. */
+export declare const remove: WriteStep & Holds<'remove'>;
+/**
+ * Change every row the `where` matches. A wrapper of its own, because a seal is keyed on
+ * the step object and two seals on one object would answer for both.
+ */
+export declare const updateMany: WriteStep & Holds<'updateMany'>;
+/** Remove every row the `where` matches, or mark it where the language names a soft delete. */
+export declare const deleteMany: WriteStep & Holds<'deleteMany'>;
+/** One row, the way `Store.find` with a limit of one answers for it. */
+export declare const findOne: ReadStep & Holds<'findOne'>;
+/** A paginated page of rows. */
+export declare const find: ReadStep & Holds<'find'>;
+/** How many rows the `where` matches, as `{ totalDocs }`, through the store's own `count` where it has one. */
+export declare const count: ReadStep & Holds<'count'>;
+/** A page of one kayan's versions, read through the row's own read access. */
+export declare const findVersions: ReadStep & Holds<'findVersions'>;
+/** One version by its own id. */
+export declare const findVersionByID: ReadStep & Holds<'findVersionByID'>;
+/** Write one version back to its row; the runner turns it into the row's own update before anything is asked. */
+export declare const restoreVersion: WriteStep & Holds<'restoreVersion'>;
+declare const sealedSteps: {
+    audit: CommonStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"audit">;
+    count: ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"count">;
+    defaults: WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"defaults">;
+    deleteMany: WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"deleteMany">;
+    find: ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"find">;
+    findOne: ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"findOne">;
+    findVersionByID: ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"findVersionByID">;
+    findVersions: ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"findVersions">;
+    insert: WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"insert">;
+    remove: WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"remove">;
+    restoreVersion: WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"restoreVersion">;
+    update: WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"update">;
+    updateMany: WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"updateMany">;
+    validate: CommonStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"validate"> & ((of?: unknown) => CommonStep);
+};
+export type Sealed = Omit<typeof sealedSteps, 'audit' | 'defaults' | 'validate'>;
+/** The shipped lists a kayan spreads into its own `targets.service.operations`: `operations: { ...defaultOperations, archive }`. */
+export declare const defaultOperations: {
+    create: {
+        steps: (WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"insert">)[];
+    };
+    update: {
+        steps: (WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"update">)[];
+    };
+    delete: {
+        steps: (WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"remove">)[];
+    };
+    find: {
+        steps: (ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"find">)[];
+    };
+    findByID: {
+        steps: (ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"findOne">)[];
+    };
+    count: {
+        steps: (ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"count">)[];
+    };
+    updateMany: {
+        steps: (WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"updateMany">)[];
+    };
+    deleteMany: {
+        steps: (WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"deleteMany">)[];
+    };
+};
+/** The two lists a global spreads into its own `targets.service.operations`: `findOne` and `update`. */
+export declare const defaultGlobalOperations: {
+    update: {
+        steps: (WriteStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"update">)[];
+    };
+    findOne: {
+        input: () => StandardSchemaV1<{
+            depth?: number;
+        }>;
+        steps: (ReadStep<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, Record<string, unknown>> & Holds<"findOne">)[];
+    };
+};
+/** The lists the shipped record carries, as a steps function is handed them. */
+export type DefaultLists = {
+    [Name in keyof typeof defaultOperations]: StepsOf<(typeof defaultOperations)[Name]>;
+};
+/** Any operations record, whatever lists its steps functions were typed against. */
+type DeclaredOperations = Record<string, AnyOperation | undefined>;
+/** A step of the runner's own three lists. `serviceTarget` narrows it to the context the same target declares. */
+export type ProjectStep = Step<Record<string, unknown>, Record<string, unknown>, unknown, unknown, unknown, never>;
+/** The language's own three lists, as an operation's function of one is handed them. */
+export type LanguageSlots = {
+    beforeSteps?: readonly ProjectStep[];
+    afterSteps?: readonly ProjectStep[];
+    afterCommit?: readonly ProjectStep[];
+};
+export declare const resolveOperations: (declared: DeclaredOperations | ((defaults: never) => DeclaredOperations) | undefined, slots?: LanguageSlots) => Record<string, AnyOperation>;
+export {};