better-supabase 0.7.1 → 0.9.0

package/dist/blocks/parties/index.d.ts

@@ -0,0 +1,181 @@
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CTreRrgP.js";
+import { b as PartyEventData } from "../../index-BlqrGvb3.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { i as CursorPageOptions } from "../../block-helpers-C86hPEjI.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BLPWD3Jt.js";
+import { i as RowFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { t as SubjectConfig } from "../../subjects-z8VWA_lF.js";
+//#region src/blocks/parties/parties.d.ts
+/** Where a page of a list stops: the last row's name and id. */
+interface PartyCursor {
+  readonly name: string;
+  readonly id: string;
+}
+interface PartyPage<T> {
+  readonly items: readonly T[];
+  /** Pass as `cursor` for the next page; `undefined` on the last page. */
+  readonly next?: PartyCursor;
+}
+interface PartyRecord {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly name: string;
+  readonly lifecycle: string;
+  readonly ownerId?: string;
+  /** Set when this record was merged into another and archived. */
+  readonly mergedInto?: string;
+  readonly archived: boolean;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: Readonly<Record<string, unknown>>;
+}
+/** A company. `F` types the extra columns the `fields` schema describes. */
+interface Company<F extends object = Record<never, never>> extends PartyRecord {
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: RowFields<F>;
+  readonly domain?: string;
+  readonly website?: string;
+  readonly vatId?: string;
+  readonly address?: Readonly<Record<string, unknown>>;
+}
+interface Person extends PartyRecord {
+  readonly email?: string;
+  readonly phone?: string;
+  readonly title?: string;
+  /** The user this person signs in as, for a portal. */
+  readonly userId?: string;
+}
+/** A person at a company. */
+interface CompanyPerson extends Person {
+  readonly role?: string;
+  /** Whether this is the company's primary contact. */
+  readonly primary: boolean;
+}
+/**
+ * The fields of a write. Left out keeps the stored value; `null` clears it
+ * (a name and a lifecycle can't be cleared).
+ */
+interface CompanyInput<F extends object = Record<never, never>> {
+  /** Leave out to create a company; `name` is then required. */
+  readonly id?: string;
+  readonly name?: string;
+  readonly domain?: string | null;
+  readonly website?: string | null;
+  readonly vatId?: string | null;
+  readonly lifecycle?: string;
+  readonly ownerId?: string | null;
+  readonly address?: Readonly<Record<string, unknown>> | null;
+  /** Values for the app's extra columns, by column name; `options.fields` checks them. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+interface PersonInput {
+  /** Leave out to create a person; `name` is then required. */
+  readonly id?: string;
+  readonly name?: string;
+  readonly email?: string | null;
+  readonly phone?: string | null;
+  readonly title?: string | null;
+  readonly lifecycle?: string;
+  readonly ownerId?: string | null;
+  readonly userId?: string | null;
+  readonly fields?: Readonly<Record<string, unknown>>;
+}
+interface PartyListOptions extends CursorPageOptions<PartyCursor> {
+  /** Matches the name, and a company's domain or a person's email. */
+  readonly search?: string;
+  readonly lifecycle?: string;
+  readonly ownerId?: string;
+}
+interface Parties<F extends object = Record<never, never>> {
+  saveCompany(organizationId: string, input: CompanyInput<F>): AsyncResult<Company<F>>;
+  savePerson(organizationId: string, input: PersonInput): AsyncResult<Person>;
+  /** Archives a company, or restores it with `archived: false`. */
+  archiveCompany(id: string, archived?: boolean): AsyncResult<boolean>;
+  archivePerson(id: string, archived?: boolean): AsyncResult<boolean>;
+  /** Links a person to a company. `primary` replaces the company's primary contact. */
+  linkPerson(companyId: string, personId: string, link?: {
+    readonly role?: string;
+    readonly primary?: boolean;
+  }): AsyncResult<boolean>;
+  unlinkPerson(companyId: string, personId: string): AsyncResult<boolean>;
+  /** Merges `drop` into `keep`. Needs `parties.manage`. */
+  mergeCompanies(keep: string, drop: string): AsyncResult<Company<F>>;
+  mergePeople(keep: string, drop: string): AsyncResult<Person>;
+  /** A page of active companies by name (50 by default, at most 200). */
+  listCompanies(organizationId: string, options?: PartyListOptions): AsyncResult<PartyPage<Company<F>>>;
+  listPeople(organizationId: string, options?: PartyListOptions): AsyncResult<PartyPage<Person>>;
+  /** A company's people with their role, primary contact first. */
+  peopleOf(companyId: string): AsyncResult<CompanyPerson[]>;
+  /** Links an inbox contact to a person. Needs the inbox module. */
+  linkInboxContact(personId: string, contactId: string): AsyncResult<boolean>;
+  unlinkInboxContact(contactId: string): AsyncResult<boolean>;
+  /**
+   * The person an inbox contact is: its link, else the person with its
+   * email (then linked), else with `create` a new lead from the contact.
+   */
+  personForInboxContact(contactId: string, options?: {
+    readonly create?: boolean;
+  }): AsyncResult<Person | undefined>;
+}
+interface PartiesOptions<S extends StandardSchemaV1 | undefined = undefined> {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the extra columns of the companies table
+   * (`blocks.parties.options.extraColumns`): writes are validated, reads
+   * parsed.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Parties<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The parties block: companies and people an organization works with.
+ * Register them in `config.subjects` with `partiesSubjects()` so comments,
+ * tags, files, pipelines and deals can point at them.
+ */
+export declare function createParties<S extends StandardSchemaV1 | undefined = undefined>(options: PartiesOptions<S>): Parties<FieldsOf<S>>;
+/**
+ * `config.subjects` entries for the parties tables, so subject-bound blocks
+ * attach to companies and people. Pass `schema` when the module isn't in
+ * `better_supabase`.
+ */
+export declare function partiesSubjects(options?: {
+  readonly schema?: string;
+  readonly url?: {
+    readonly company?: string;
+    readonly person?: string;
+  };
+}): {
+  readonly company: SubjectConfig;
+  readonly person: SubjectConfig;
+};
+//#endregion
+//#region src/blocks/parties/events.d.ts
+/** The events of the `parties` block: type to data. */
+type PartiesEvents = {
+  readonly "company.created": PartyEventData;
+  readonly "company.updated": PartyEventData;
+  readonly "company.archived": PartyEventData;
+  readonly "company.merged": PartyEventData;
+  readonly "company.person_linked": PartyEventData;
+  readonly "company.person_unlinked": PartyEventData;
+  readonly "person.created": PartyEventData;
+  readonly "person.updated": PartyEventData;
+  readonly "person.archived": PartyEventData;
+  readonly "person.merged": PartyEventData;
+};
+/** The `parties` block's event types, for its manifest and `onBlockEvent`. */
+export declare const partiesEvents: Events<PartiesEvents>;
+//#endregion
+//#region src/blocks/parties/manifest.d.ts
+/** The `parties` block's manifest (ADR 0029). */
+export declare const partiesBlock: BlockOf<"parties", typeof createParties, PartiesEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Company, type CompanyInput, type CompanyPerson, type Parties, type PartiesEvents, type PartiesOptions, type PartyCursor, type PartyListOptions, type PartyPage, type Person, type PersonInput, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/parties/index.js

@@ -0,0 +1,258 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall, w as pageOf } from "../../block-helpers-CfG_MvDR.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { a as readAllFields, l as writeFields, n as blockFields, o as readFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as partiesSqlOptions } from "../../options-xVAy3UsV.js";
+//#region src/blocks/parties/parties.ts
+const COMMON = [
+	"id",
+	"tenant_id",
+	"name",
+	"lifecycle",
+	"owner_user_id",
+	"merged_into",
+	"archived_at",
+	"created_by",
+	"created_at",
+	"updated_at"
+];
+const COMPANY_COLUMNS = /* @__PURE__ */ new Set([
+	...COMMON,
+	"domain",
+	"website",
+	"vat_id",
+	"address"
+]);
+const PERSON_COLUMNS = /* @__PURE__ */ new Set([
+	...COMMON,
+	"email",
+	"phone",
+	"title",
+	"user_id",
+	"role",
+	"is_primary"
+]);
+const fieldsOf = (row, known) => Object.fromEntries(Object.entries(row).filter(([key]) => !known.has(key)));
+function base(row, known) {
+	const fields = row["fields"];
+	const ownerId = optionalText(row["owner_user_id"]);
+	const mergedInto = optionalText(row["merged_into"]);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["tenant_id"]),
+		name: textOf(row["name"]),
+		lifecycle: textOf(row["lifecycle"]),
+		archived: row["archived_at"] !== null && row["archived_at"] !== void 0,
+		fields: isRecord(fields) ? fields : fieldsOf(row, known),
+		...ownerId === void 0 ? {} : { ownerId },
+		...mergedInto === void 0 ? {} : { mergedInto }
+	};
+}
+function companyOf(value) {
+	const row = recordOf(value, "company");
+	const domain = optionalText(row["domain"]);
+	const website = optionalText(row["website"]);
+	const vatId = optionalText(row["vat_id"]);
+	const address = row["address"];
+	return {
+		...base(row, COMPANY_COLUMNS),
+		...domain === void 0 ? {} : { domain },
+		...website === void 0 ? {} : { website },
+		...vatId === void 0 ? {} : { vatId },
+		...isRecord(address) ? { address } : {}
+	};
+}
+function personOf(value) {
+	const row = recordOf(value, "person");
+	const email = optionalText(row["email"]);
+	const phone = optionalText(row["phone"]);
+	const title = optionalText(row["title"]);
+	const userId = optionalText(row["user_id"]);
+	return {
+		...base(row, PERSON_COLUMNS),
+		...email === void 0 ? {} : { email },
+		...phone === void 0 ? {} : { phone },
+		...title === void 0 ? {} : { title },
+		...userId === void 0 ? {} : { userId }
+	};
+}
+function companyPersonOf(value) {
+	const row = recordOf(value, "company person");
+	const role = optionalText(row["role"]);
+	return {
+		...personOf(row),
+		primary: row["is_primary"] === true,
+		...role === void 0 ? {} : { role }
+	};
+}
+/** The attrs of a write: the keys the input sets, `null` included, and its fields. */
+function attrsOf(input) {
+	const { id: _id, fields, ...rest } = input;
+	return {
+		...rest,
+		...fields
+	};
+}
+function pageFrom(rows, limit) {
+	const last = rows.at(-1);
+	return rows.length === (limit ?? 50) && last !== void 0 ? {
+		items: rows,
+		next: {
+			name: last.name,
+			id: last.id
+		}
+	} : { items: rows };
+}
+/**
+* The parties block: companies and people an organization works with.
+* Register them in `config.subjects` with `partiesSubjects()` so comments,
+* tags, files, pipelines and deals can point at them.
+*/
+function createParties(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "company fields");
+	const company = (result) => result.andThen((row) => readFields(fields, row));
+	const list = (fn, organizationId, listOptions, map) => {
+		const { limit, cursor } = pageOf(listOptions);
+		return call(fn, {
+			tenant: organizationId,
+			search: listOptions.search ?? null,
+			lifecycle: listOptions.lifecycle ?? null,
+			owner: listOptions.ownerId ?? null,
+			after_name: cursor?.name ?? null,
+			after_id: cursor?.id ?? null,
+			page_size: limit ?? null
+		}, (value) => pageFrom(recordsOf(value, fn).map(map), limit));
+	};
+	return withBlockHooks({
+		saveCompany: (organizationId, input) => writeFields(fields, input.fields, (checked) => company(call("save_company", {
+			tenant: organizationId,
+			company: input.id ?? null,
+			attrs: attrsOf({
+				...input,
+				...checked === void 0 ? {} : { fields: checked }
+			})
+		}, companyOf))),
+		savePerson: (organizationId, input) => call("save_person", {
+			tenant: organizationId,
+			person: input.id ?? null,
+			attrs: attrsOf(input)
+		}, personOf),
+		archiveCompany: (id, archived = true) => call("archive_company", {
+			id,
+			archived
+		}, (value) => value === true),
+		archivePerson: (id, archived = true) => call("archive_person", {
+			id,
+			archived
+		}, (value) => value === true),
+		linkPerson: (companyId, personId, link = {}) => call("set_company_person", {
+			company: companyId,
+			person: personId,
+			role: link.role ?? null,
+			is_primary: link.primary ?? false
+		}, (value) => value === true),
+		unlinkPerson: (companyId, personId) => call("remove_company_person", {
+			company: companyId,
+			person: personId
+		}, (value) => value === true),
+		mergeCompanies: (keep, drop) => company(call("merge_companies", {
+			keep,
+			drop
+		}, companyOf)),
+		mergePeople: (keep, drop) => call("merge_people", {
+			keep,
+			drop
+		}, personOf),
+		listCompanies: (organizationId, listOptions = {}) => list("list_companies", organizationId, listOptions, companyOf).andThen((page) => readAllFields(fields, page.items).map((items) => ({
+			...page,
+			items
+		}))),
+		listPeople: (organizationId, listOptions = {}) => list("list_people", organizationId, listOptions, personOf),
+		linkInboxContact: (personId, contactId) => call("link_inbox_contact", {
+			person: personId,
+			contact: contactId
+		}, (value) => value === true),
+		unlinkInboxContact: (contactId) => call("unlink_inbox_contact", { contact: contactId }, (value) => value === true),
+		personForInboxContact: (contactId, find = {}) => call("person_for_inbox_contact", {
+			contact: contactId,
+			create: find.create ?? false
+		}, (value) => value === null ? void 0 : personOf(value)),
+		peopleOf: (companyId) => call("company_people_of", { company: companyId }, (value) => recordsOf(value, "company_people_of").map(companyPersonOf))
+	}, options.hooks, {
+		block: "parties",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+/**
+* `config.subjects` entries for the parties tables, so subject-bound blocks
+* attach to companies and people. Pass `schema` when the module isn't in
+* `better_supabase`.
+*/
+function partiesSubjects(options = {}) {
+	const schema = options.schema ?? "better_supabase";
+	return {
+		company: {
+			table: `${schema}.companies`,
+			idType: "uuid",
+			tenant: "tenant_id",
+			title: "name",
+			permissions: {
+				read: "parties.read",
+				write: "parties.write"
+			},
+			search: {
+				title: "name",
+				body: ["domain"]
+			},
+			...options.url?.company === void 0 ? {} : { url: options.url.company }
+		},
+		person: {
+			table: `${schema}.people`,
+			idType: "uuid",
+			tenant: "tenant_id",
+			title: "name",
+			permissions: {
+				read: "parties.read",
+				write: "parties.write"
+			},
+			search: {
+				title: "name",
+				body: ["email", "title"]
+			},
+			...options.url?.person === void 0 ? {} : { url: options.url.person }
+		}
+	};
+}
+//#endregion
+//#region src/blocks/parties/events.ts
+/** The `parties` block's event types, for its manifest and `onBlockEvent`. */
+const partiesEvents = defineEvents({
+	"company.created": event(),
+	"company.updated": event(),
+	"company.archived": event(),
+	"company.merged": event(),
+	"company.person_linked": event(),
+	"company.person_unlinked": event(),
+	"person.created": event(),
+	"person.updated": event(),
+	"person.archived": event(),
+	"person.merged": event()
+});
+//#endregion
+//#region src/blocks/parties/manifest.ts
+/** The `parties` block's manifest (ADR 0029). */
+const partiesBlock = defineBlock({
+	name: "parties",
+	sql: ["parties"],
+	options: { parties: partiesSqlOptions },
+	events: partiesEvents,
+	create: createParties,
+	category: "crm",
+	recipes: ["contact-detail"]
+});
+//#endregion
+export { createParties, dbTransport, extendBlock, partiesBlock, partiesEvents, partiesSubjects, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/pipelines/index.d.ts

@@ -0,0 +1,189 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CTreRrgP.js";
+import { S as PipelineStageEventData, x as PipelineEventData } from "../../index-BlqrGvb3.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BLPWD3Jt.js";
+import { i as RowFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { t as RankNeighbors } from "../../rank-result-Dngpt2n5.js";
+import { n as Money } from "../../money-DFpWzQvk.js";
+//#region src/blocks/pipelines/pipelines.d.ts
+/** The fixed outcome every stage category maps to. */
+type PipelineOutcome = "open" | "success" | "failure";
+interface PipelineStage {
+  readonly id: string;
+  readonly pipelineId: string;
+  readonly key: string;
+  /** The key the stage was seeded with, which renames keep. */
+  readonly systemKey?: string;
+  readonly name: string;
+  readonly color?: string;
+  readonly rank: string;
+  /** A category the subject type declares, such as `won` or `started`. */
+  readonly category: string;
+  readonly outcome: PipelineOutcome;
+  /** Win probability 0 to 100, the default for records in the stage. */
+  readonly probability?: number;
+  readonly rottingAfterDays?: number;
+  readonly wipLimit?: number;
+}
+interface Pipeline<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subjectType: string;
+  /** The scope the pipeline belongs to, such as one job's id. */
+  readonly scopeId?: string;
+  readonly key: string;
+  readonly name: string;
+  readonly rank: string;
+  readonly isDefault: boolean;
+  /** Its active stages in board order. Empty on the result of `save`. */
+  readonly stages: readonly PipelineStage[];
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: RowFields<F>;
+}
+interface PipelineInput<F extends object = Record<never, never>> {
+  /** Leave out to create a pipeline. */
+  readonly id?: string;
+  readonly subjectType: string;
+  readonly key: string;
+  readonly name: string;
+  readonly scopeId?: string;
+  readonly isDefault?: boolean;
+  /** Values for the app's extra columns (`options.extraColumns`); left out keeps the stored ones. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+interface PipelineStageInput {
+  /** Leave out to add a stage at the end. */
+  readonly id?: string;
+  readonly key: string;
+  readonly name: string;
+  readonly category: string;
+  readonly probability?: number;
+  readonly rottingAfterDays?: number;
+  readonly wipLimit?: number;
+  readonly color?: string;
+}
+/** An allowed stage change. Without any, every change is allowed. */
+interface PipelineTransition {
+  readonly from: string;
+  readonly to: string;
+}
+/** One currency's totals in a board column. */
+interface PipelineTotal {
+  readonly currency: string;
+  readonly amount: Money;
+  /** The amount times each record's probability (or its stage's), rounded. */
+  readonly weighted: Money;
+}
+/** One board column: a stage with the records the caller can see in it. */
+interface PipelineColumn {
+  readonly stageId: string;
+  readonly key: string;
+  readonly name: string;
+  readonly color?: string;
+  readonly category: string;
+  readonly outcome: PipelineOutcome;
+  readonly probability?: number;
+  readonly wipLimit?: number;
+  readonly count: number;
+  /** Whether the column holds more records than its WIP limit. */
+  readonly overLimit: boolean;
+  readonly totals: readonly PipelineTotal[];
+}
+interface PipelineStats {
+  readonly won: number;
+  readonly lost: number;
+  /** Won over won plus lost, or `undefined` when nothing closed. */
+  readonly winRate?: number;
+  readonly stages: readonly {
+    readonly stageId: string;
+    readonly key: string;
+    readonly entered: number;
+    /** How long records that left the stage stayed, on average. */
+    readonly averageSeconds?: number;
+  }[];
+}
+/** An open record and how long it has been in its stage. */
+interface PipelineHealth {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly stageId: string;
+  readonly enteredAt: Temporal.Instant;
+  readonly daysInStage: number;
+  /** Whether it sits longer than the stage's rotting limit. */
+  readonly rotting: boolean;
+}
+interface Pipelines<F extends object = Record<never, never>> {
+  /** The organization's active pipelines of a subject type, with their stages. */
+  list(organizationId: string, subjectType: string): AsyncResult<Pipeline<F>[]>;
+  /** Creates or renames a pipeline. The first of a type and scope is its default. */
+  save(organizationId: string, input: PipelineInput<F>): AsyncResult<Pipeline<F>>;
+  /** Archives a pipeline that holds no records. */
+  archive(pipelineId: string): AsyncResult<boolean>;
+  /** Adds a stage at the end of a pipeline, or changes one. */
+  saveStage(pipelineId: string, input: PipelineStageInput): AsyncResult<PipelineStage>;
+  /** Moves a stage between the stages with rank keys `previous` and `next`. */
+  reorderStage(stageId: string, neighbors: RankNeighbors): AsyncResult<string>;
+  /** Archives an empty stage. A pipeline keeps at least one open stage. */
+  archiveStage(stageId: string): AsyncResult<boolean>;
+  /** Replaces the allowed stage changes. An empty list allows every change. */
+  setTransitions(pipelineId: string, transitions: readonly PipelineTransition[]): AsyncResult<number>;
+  /** The board: each active stage with its count and totals per currency. */
+  board(subjectType: string, pipelineId: string, options?: {
+    readonly owner?: string;
+  }): AsyncResult<PipelineColumn[]>;
+  /** Entries, time in stage and win rate from the stage history. */
+  stats(pipelineId: string, window: {
+    readonly since: Temporal.Instant;
+    readonly until: Temporal.Instant;
+  }): AsyncResult<PipelineStats>;
+  /** The open records, oldest entry first, with their days in stage. */
+  health(pipelineId: string): AsyncResult<PipelineHealth[]>;
+}
+interface PipelinesOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the extra columns of the pipelines table
+   * (`blocks.pipelines.options.extraColumns`): writes are validated, reads
+   * parsed.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Pipelines<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The pipelines block: tenant-editable pipelines and stages for the subject
+ * types `blocks.pipelines.options.subjects` binds, and the board,
+ * stats and health reads over them. Moving a record is a plain update of
+ * its stage column, or `rank.move` with the stage id as the group.
+ */
+export declare function createPipelines<S extends StandardSchemaV1 | undefined = undefined>(options: PipelinesOptions<S>): Pipelines<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/pipelines/events.d.ts
+/** The events of the `pipelines` block: type to data. */
+type PipelinesEvents = {
+  readonly "pipeline.created": PipelineEventData;
+  readonly "pipeline.updated": PipelineEventData;
+  readonly "pipeline.archived": PipelineEventData;
+  readonly "pipeline_stage.saved": PipelineEventData;
+  readonly "pipeline_stage.archived": PipelineEventData;
+  readonly "pipeline.stage_changed": PipelineStageEventData;
+};
+/** The `pipelines` block's event types, for its manifest and `onBlockEvent`. */
+export declare const pipelinesEvents: Events<PipelinesEvents>;
+//#endregion
+//#region src/blocks/pipelines/manifest.d.ts
+/** The `pipelines` block's manifest (ADR 0029). */
+export declare const pipelinesBlock: BlockOf<"pipelines", typeof createPipelines, PipelinesEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Pipeline, type PipelineColumn, type PipelineHealth, type PipelineInput, type PipelineOutcome, type PipelineStage, type PipelineStageInput, type PipelineStats, type PipelineTotal, type PipelineTransition, type Pipelines, type PipelinesEvents, type PipelinesOptions, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };