better-supabase 0.13.0 → 0.14.0

package/dist/flags-BhYByvP1.js

@@ -0,0 +1,279 @@
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { t as DEFAULT_CLAIMS } from "./claims-Bp9My7XP.js";
+import { C as optionalText, F as stringsOf, I as textOf, f as errorText, k as recordsOf, n as applyTemporal, o as blockCall } from "./block-helpers-CiKtrb6g.js";
+//#region src/blocks/flags/flags.ts
+const BUCKETS = 1e4;
+/**
+* The rollout bucket of `target` for `flag`, 0 to 9999: the first 32 bits of
+* SHA-256(`flag.target`) modulo 10000. `better_supabase.flag_bucket()` computes
+* the same number, so SQL and TypeScript agree on who is in.
+*/
+async function flagBucket(flag, target) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${flag}.${target}`));
+	return new DataView(digest).getUint32(0) % BUCKETS;
+}
+const contains = (list, value) => list === void 0 || value !== void 0 && list.includes(value);
+const anyIn = (list, values) => list === void 0 || values.some((value) => list.includes(value));
+function ruleMatches(rule, context) {
+	return contains(rule.tenants, context.tenant) && contains(rule.users, context.targetingKey) && anyIn(rule.roles, [...context.role === void 0 ? [] : [context.role], ...context.roles ?? []]) && (rule.plans === void 0 || rule.plans.some((plan) => context.plans?.includes(plan) === true)) && (rule.contexts === void 0 || Object.entries(rule.contexts).every(([name, keys]) => contains(keys, context.contexts?.[name])));
+}
+async function chooseVariant(flag, context) {
+	if (!flag.enabled || flag.archived === true) return {
+		variant: flag.defaultVariant,
+		reason: "DISABLED"
+	};
+	let chosen = (flag.overrides.find((entry) => entry.userId !== void 0 && entry.userId === context.targetingKey) ?? flag.overrides.find((entry) => entry.organizationId !== void 0 && entry.organizationId === context.tenant) ?? flag.overrides.find((entry) => entry.context !== void 0 && entry.contextKey !== void 0 && entry.contextKey === context.contexts?.[entry.context]))?.variant;
+	let reason = chosen === void 0 ? "DEFAULT" : "TARGETING_MATCH";
+	if (chosen === void 0) {
+		const rule = flag.rules.find((entry) => ruleMatches(entry, context));
+		if (rule) {
+			chosen = rule.variant;
+			reason = "TARGETING_MATCH";
+		}
+	}
+	const target = context.targetingKey ?? context.tenant;
+	if (chosen === void 0 && flag.rolloutVariant !== void 0 && target !== void 0 && await flagBucket(flag.key, target) < flag.rolloutPercentage * 100) {
+		chosen = flag.rolloutVariant;
+		reason = "SPLIT";
+	}
+	if (chosen === void 0 || !Object.hasOwn(flag.variants, chosen)) return {
+		variant: flag.defaultVariant,
+		reason: "DEFAULT"
+	};
+	return {
+		variant: chosen,
+		reason
+	};
+}
+/** Evaluates one flag as `better_supabase.flag_evaluation()` does. */
+async function evaluateFlag(flag, context = {}) {
+	const { variant, reason } = await chooseVariant(flag, context);
+	const found = Object.hasOwn(flag.variants, variant);
+	return {
+		value: found ? flag.variants[variant] ?? null : null,
+		variant,
+		reason,
+		found
+	};
+}
+const FLAG_TYPES = /* @__PURE__ */ new Set([
+	"boolean",
+	"string",
+	"number",
+	"object"
+]);
+const flagTypeOf = (value) => {
+	const text = textOf(value);
+	if (value === void 0 || value === null || FLAG_TYPES.has(text)) return { type: FLAG_TYPES.has(text) ? text : "boolean" };
+	return {
+		type: "boolean",
+		invalidType: text
+	};
+};
+function ruleOf(value) {
+	if (!isRecord(value) || typeof value["variant"] !== "string") return;
+	const list = (key) => Array.isArray(value[key]) ? stringsOf(value[key]) : void 0;
+	const tenants = list("tenants");
+	const users = list("users");
+	const plans = list("plans");
+	const roles = list("roles");
+	const raw = value["contexts"];
+	const contexts = isRecord(raw) ? Object.fromEntries(Object.entries(raw).map(([name, keys]) => [name, Array.isArray(keys) ? stringsOf(keys) : []])) : void 0;
+	return {
+		variant: value["variant"],
+		...tenants && { tenants },
+		...users && { users },
+		...plans && { plans },
+		...roles && { roles },
+		...contexts && { contexts }
+	};
+}
+/** Parses the rows of `flag_definitions()`. */
+function flagDefinitionsOf(value) {
+	return recordsOf(value, "flag_definitions").map((row) => ({
+		key: textOf(row["key"]),
+		...flagTypeOf(row["type"]),
+		variants: isRecord(row["variants"]) ? row["variants"] : {},
+		defaultVariant: optionalText(row["default_variant"]) ?? "",
+		...optionalText(row["description"]) !== void 0 && { description: textOf(row["description"]) },
+		enabled: row["enabled"] !== false,
+		...row["archived"] === true && { archived: true },
+		rules: (Array.isArray(row["rules"]) ? row["rules"] : []).flatMap((rule) => {
+			const parsed = ruleOf(rule);
+			return parsed ? [parsed] : [];
+		}),
+		rolloutPercentage: Number(row["rollout_percentage"] ?? 0),
+		rolloutVariant: optionalText(row["rollout_variant"]),
+		overrides: recordsOf(row["overrides"] ?? [], "flag_definitions").map(overrideOf),
+		...optionalText(row["updated_at"]) !== void 0 && { updatedAt: textOf(row["updated_at"]) },
+		...isRecord(row["fields"]) ? { fields: row["fields"] } : {}
+	}));
+}
+function overrideOf(entry) {
+	const context = optionalText(entry["context"]);
+	const contextKey = optionalText(entry["context_key"]);
+	return {
+		organizationId: optionalText(entry["organization_id"]),
+		userId: optionalText(entry["user_id"]),
+		...context !== void 0 && { context },
+		...contextKey !== void 0 && { contextKey },
+		variant: textOf(entry["variant"])
+	};
+}
+const DEFAULT_CODES = {
+	FLAG_NOT_FOUND: "FLAG_NOT_FOUND",
+	TYPE_MISMATCH: "TYPE_MISMATCH",
+	PARSE_ERROR: "PARSE_ERROR",
+	PROVIDER_NOT_READY: "PROVIDER_NOT_READY",
+	GENERAL: "GENERAL"
+};
+const isBoolean = (value) => typeof value === "boolean";
+const isString = (value) => typeof value === "string";
+const isNumber = (value) => typeof value === "number";
+/** Feature flags from the `flags` module, as an OpenFeature provider. */
+function createFlagsProvider(options) {
+	applyTemporal(options);
+	const { transport, definitions } = options;
+	const call = transport === void 0 ? void 0 : blockCall(transport, options.schema ?? "better_supabase", options.mappers);
+	const fetchFlags = definitions ? () => Promise.resolve(definitions) : call ? () => call("flag_definitions", {}, flagDefinitionsOf).orThrow() : void 0;
+	if (!fetchFlags) throw new TypeError("createFlagsProvider needs a transport or definitions");
+	const ttl = options.ttl ?? 3e4;
+	const now = options.now ?? Date.now;
+	const codes = options.errorCodes ?? DEFAULT_CODES;
+	let cache;
+	const load = () => {
+		if (cache && now() - cache.at < ttl) return cache.flags;
+		const flags = fetchFlags().then((list) => new Map(list.map((flag) => [flag.key, flag])));
+		const entry = {
+			at: now(),
+			flags
+		};
+		cache = entry;
+		flags.catch(() => {
+			if (cache === entry) cache = void 0;
+		});
+		return flags;
+	};
+	async function resolve(flagKey, defaultValue, context, check) {
+		let flags;
+		try {
+			flags = await load();
+		} catch (error) {
+			return {
+				value: defaultValue,
+				reason: "ERROR",
+				errorCode: codes.GENERAL,
+				errorMessage: errorText(error)
+			};
+		}
+		const flag = flags.get(flagKey);
+		if (!flag) return {
+			value: defaultValue,
+			reason: "ERROR",
+			errorCode: codes.FLAG_NOT_FOUND,
+			errorMessage: `Flag "${flagKey}" is not defined`
+		};
+		if (flag.invalidType !== void 0) return {
+			value: defaultValue,
+			reason: "ERROR",
+			errorCode: codes.PARSE_ERROR ?? codes.GENERAL,
+			errorMessage: `Flag "${flagKey}" has the unknown type "${flag.invalidType}"`
+		};
+		const result = await evaluateFlag(flag, context);
+		if (!check(result.value)) return {
+			value: defaultValue,
+			reason: "ERROR",
+			errorCode: codes.TYPE_MISMATCH,
+			errorMessage: `Flag "${flagKey}" is a ${flag.type} flag`
+		};
+		return {
+			value: result.value,
+			variant: result.variant,
+			reason: result.reason
+		};
+	}
+	return {
+		metadata: { name: "better-supabase" },
+		runsOn: "server",
+		async initialize() {
+			await load();
+		},
+		resolveBooleanEvaluation: (flagKey, defaultValue, context) => resolve(flagKey, defaultValue, context, isBoolean),
+		resolveStringEvaluation: (flagKey, defaultValue, context) => resolve(flagKey, defaultValue, context, isString),
+		resolveNumberEvaluation: (flagKey, defaultValue, context) => resolve(flagKey, defaultValue, context, isNumber),
+		resolveObjectEvaluation: (flagKey, defaultValue, context) => resolve(flagKey, defaultValue, context, (value) => typeof value === "object" && value !== null),
+		definitions: async () => [...(await load()).values()],
+		refresh() {
+			cache = void 0;
+		}
+	};
+}
+const details = async (flagKey, resolution) => ({
+	flagKey,
+	flagMetadata: {},
+	...await resolution
+});
+/**
+* A flag client without the OpenFeature SDK: `withOpenFeature({ client })` from
+* `@supabase-labs/middleware-openfeature` accepts it.
+*/
+function createFlagClient(source) {
+	const provider = "resolveBooleanEvaluation" in source ? source : createFlagsProvider(source);
+	return {
+		getBooleanDetails: (flagKey, defaultValue, context = {}) => details(flagKey, provider.resolveBooleanEvaluation(flagKey, defaultValue, context)),
+		getStringDetails: (flagKey, defaultValue, context = {}) => details(flagKey, provider.resolveStringEvaluation(flagKey, defaultValue, context)),
+		getNumberDetails: (flagKey, defaultValue, context = {}) => details(flagKey, provider.resolveNumberEvaluation(flagKey, defaultValue, context)),
+		getObjectDetails: (flagKey, defaultValue, context = {}) => details(flagKey, provider.resolveObjectEvaluation(flagKey, defaultValue, context))
+	};
+}
+/**
+* The caller's roles in `tenant` from the memberships claim: an object of
+* tenant id to role (the `tenant` module's hook), or a list of `{ scope, id,
+* role | roles }` entries (an authorization provider's hook).
+*/
+function membershipRoles(memberships, tenant, scope) {
+	if (isRecord(memberships)) {
+		const role = optionalText(memberships[tenant]);
+		return role === void 0 ? [] : [role];
+	}
+	if (!Array.isArray(memberships)) return [];
+	const entry = memberships.find((item) => isRecord(item) && optionalText(item["id"]) === tenant && (scope === void 0 ? item["within"] === void 0 : optionalText(item["scope"]) === scope));
+	if (!entry) return [];
+	const role = optionalText(entry["role"]);
+	return [...role === void 0 ? [] : [role], ...stringsOf(entry["roles"])];
+}
+/**
+* The evaluation context of a request: the user id as `targetingKey`, the
+* tenant, its plan features (`features` claim) and the caller's roles in it
+* (`memberships` claim, in the `tenant` module's or the list shape, or
+* `options.roles`). Pass it as `context` to `withOpenFeature`.
+*/
+function flagContext(source, options = {}) {
+	const claims = source.jwtClaims ?? {};
+	const appMetadata = isRecord(claims["app_metadata"]) ? claims["app_metadata"] : {};
+	const tenantClaim = options.tenantClaim ?? DEFAULT_CLAIMS.tenant;
+	const tenant = source.tenant ?? optionalText(claims[tenantClaim]) ?? optionalText(appMetadata[tenantClaim]);
+	const sub = optionalText(claims["sub"]);
+	const features = claims[options.featuresClaim ?? DEFAULT_CLAIMS.features];
+	const memberships = claims[options.membershipsClaim ?? DEFAULT_CLAIMS.memberships];
+	const plans = tenant !== void 0 && isRecord(features) && Array.isArray(features[tenant]) ? [...stringsOf(features[tenant])] : void 0;
+	const resolved = tenant === void 0 ? void 0 : options.roles ? options.roles(claims, tenant) : membershipRoles(memberships, tenant, options.membershipScope);
+	const roles = resolved === void 0 ? [] : typeof resolved === "string" ? [resolved] : [...resolved];
+	const contexts = /* @__PURE__ */ new Map();
+	for (const [name, claim] of Object.entries(options.contextClaims ?? {})) {
+		const value = optionalText(claims[claim]) ?? optionalText(appMetadata[claim]);
+		if (value !== void 0) contexts.set(name, value);
+	}
+	for (const [name, value] of Object.entries(source.contexts ?? {})) if (typeof value === "string") contexts.set(name, value);
+	else contexts.delete(name);
+	return {
+		...sub !== void 0 && { targetingKey: sub },
+		...tenant !== void 0 && { tenant },
+		...plans !== void 0 && { plans },
+		...roles.length > 0 && { role: roles[0] },
+		...roles.length > 1 && { roles },
+		...contexts.size > 0 && { contexts: Object.fromEntries(contexts) }
+	};
+}
+//#endregion
+export { flagContext as a, flagBucket as i, createFlagsProvider as n, flagDefinitionsOf as o, evaluateFlag as r, createFlagClient as t };

package/dist/flags-sdk/index.d.ts

@@ -1,4 +1,4 @@
-import { a as FlagDefinition, g as FlagsProviderOptions, h as FlagsProvider, m as FlagValue, n as FlagContext, r as FlagContextOptions } from "../flags-CJFDNAvL.js";
+import { a as FlagDefinition, g as FlagsProviderOptions, h as FlagsProvider, m as FlagValue, n as FlagContext, r as FlagContextOptions } from "../flags-BTDPaN11.js";
 //#region src/flags-sdk/flags-sdk.d.ts
 /** One Flags SDK entity; Vercel Flags targets it as `<name>.id`. */
 interface FlagsSdkEntity {

package/dist/flags-sdk/index.js

@@ -1,5 +1,5 @@
-import { f as errorText } from "../block-helpers-DwE32_gT.js";
-import { a as flagContext, n as createFlagsProvider, r as evaluateFlag } from "../flags-C--SBMT9.js";
+import { f as errorText } from "../block-helpers-CiKtrb6g.js";
+import { a as flagContext, n as createFlagsProvider, r as evaluateFlag } from "../flags-BhYByvP1.js";
 //#region src/flags-sdk/flags-sdk.ts
 function originOf(origin, key) {
 	return typeof origin === "function" ? origin(key) : origin?.replaceAll("{key}", encodeURIComponent(key));

package/dist/flows/index.d.ts

@@ -0,0 +1,247 @@
+import { f as Result, t as AsyncResult } from "../result-C6jDfedy.js";
+import { H as InboxEventData, tt as SchedulingEventData } from "../events-DbLjvxDX.js";
+import { S as QuoteEventData, t as ApplicationEventData } from "../block-events-records-BGVyoz57.js";
+import { c as EmployeeInput, i as Employee } from "../employees-Dwyvxs4r.js";
+import { n as EngagementInput, r as EngagementSubject, t as Engagement } from "../engagements-CsJhf2OM.js";
+import { i as Conversation } from "../types-DkPE7yd2.js";
+import { o as WorkItem, u as WorkItemInput } from "../work-items-Cnntm8ij.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/flows/flow.d.ts
+/** A record a flow reads from or creates: its subject type and id. */
+interface FlowRef {
+  readonly type: string;
+  readonly id: string;
+}
+/**
+ * An event a flow starts from. An outbox event fits; a job keeps only these
+ * fields, so they stay JSON.
+ */
+interface FlowEvent<P = unknown> {
+  readonly id: string;
+  readonly type: string;
+  readonly payload: P;
+  readonly subject?: string | null;
+  readonly tenant?: string | null;
+  readonly actorId?: string | null;
+}
+/** The part of the relations block a flow uses; `blocks.relations` fits. */
+interface FlowRelations {
+  link(source: FlowRef, target: FlowRef, input: {
+    readonly kind: "created_from";
+  }): PromiseLike<Result<unknown>>;
+  convertedInto(origin: FlowRef, intoType: string): PromiseLike<Result<string | undefined>>;
+}
+/** The clients every flow gets; a flow names the other blocks it needs. */
+interface FlowClients {
+  readonly relations: FlowRelations;
+}
+/** What a flow's hooks receive for one event. */
+interface FlowContext<C, P = unknown> {
+  readonly clients: C;
+  /** The organization the event belongs to. */
+  readonly tenant: string;
+  readonly event: FlowEvent<P>;
+  /** The record the event is about, from `source`. */
+  readonly source: FlowRef;
+}
+interface FlowSpec<C, P, S, T> {
+  /** Unique among the flows of one `createFlows`; it keys the job dedupe. */
+  readonly name: string;
+  /** The event type, or types, that start the flow. */
+  readonly on: string | readonly string[];
+  /** The subject type the flow creates, such as `work_item`. */
+  readonly target: string;
+  /** The record the event is about; `undefined` skips the event. */
+  readonly source: (event: FlowEvent<P>) => FlowRef | undefined;
+  /** Reads what `map` needs, such as the source record. */
+  readonly load?: (context: FlowContext<C, P>) => PromiseLike<Result<S>>;
+  /**
+   * The target block's input schema (`block.schemas.<entity>.input`): the
+   * mapped value must pass it before `create` runs.
+   */
+  readonly input?: StandardSchemaV1<T>;
+  /** Turns what `load` read into the target block's input. */
+  readonly map: (loaded: S, context: FlowContext<C, P>) => T;
+  /** Creates the target record and returns its id. */
+  readonly create: (input: T, context: FlowContext<C, P>) => PromiseLike<Result<{
+    readonly id: string;
+  }>>;
+  /**
+   * The target block records the `created_from` link itself, as
+   * `employees.fromApplication` does.
+   */
+  readonly linksItself?: boolean;
+}
+/** A flow from `defineFlow` (`apiVersion: 1`). */
+interface Flow<C extends FlowClients = FlowClients, P = unknown, S = unknown, T = unknown> extends FlowSpec<C, P, S, T> {
+  readonly apiVersion: 1;
+}
+type Varies = any;
+/** A flow over any payload, loaded value and input, for `createFlows`. */
+type AnyFlow<C extends FlowClients = FlowClients> = Flow<C, Varies, Varies, Varies>;
+/**
+ * Declares a flow: when an event of type `on` arrives, read the source record,
+ * map it to the target block's input and create the target record, once. The
+ * new record is linked `created_from` the source, so `relations.lineage` finds
+ * the chain and a second run returns the first record.
+ */
+export declare function defineFlow<C extends FlowClients, P = unknown, S = undefined, T = unknown>(spec: FlowSpec<C, P, S, T>): Flow<C, P, S, T>;
+/** What `run` did with one event. */
+type FlowOutcome = {
+  readonly status: "created";
+  readonly target: FlowRef;
+} | {
+  readonly status: "exists";
+  readonly target: FlowRef;
+} | {
+  readonly status: "skipped";
+};
+/** A queued flow run: the flow's name and the event, as JSON. */
+interface FlowJob {
+  readonly flow: string;
+  readonly event: FlowEvent;
+}
+interface FlowsOptions<C extends FlowClients> {
+  /** The flows to turn on. A built-in runs only when it is listed here. */
+  readonly flows: readonly AnyFlow<C>[];
+  /**
+   * The block clients for one tenant, such as `createBlocks` with `tenant: ()
+   * => tenant` over a service connection.
+   */
+  readonly clients: (tenant: string, event: FlowEvent) => C | PromiseLike<C>;
+  /**
+   * Queues each run as a job instead of running it in the outbox consumer, such
+   * as `(job, dedupeKey) => jobs.enqueueOnce("flows", job, { dedupeKey })`. The
+   * key is `flow:<name>:<event id>`, so a redelivered event queues once.
+   */
+  readonly enqueue?: (job: FlowJob, dedupeKey: string) => PromiseLike<Result<unknown>>;
+  /** Receives each run's outcome. */
+  readonly onOutcome?: (flow: string, event: FlowEvent, outcome: FlowOutcome) => void;
+}
+interface Flows {
+  /** The flows that start on an event type. */
+  matching(type: string): readonly string[];
+  /** Runs one flow for one event, once: a second run returns `exists`. */
+  run(flow: string, event: FlowEvent): AsyncResult<FlowOutcome>;
+  /**
+   * The outbox consumer, for `outbox.consume("flows", flows.sink())`. It throws
+   * when a run or an enqueue fails, so the outbox delivers the event again; the
+   * runs that already finished find their record and return `exists`.
+   */
+  sink(): (events: readonly FlowEvent[]) => Promise<void>;
+  /** The job handler for the queue `enqueue` writes to. */
+  handler(): (payload: FlowJob) => Promise<void>;
+}
+/**
+ * Turns flows on: an outbox consumer that runs, or queues, every flow whose
+ * `on` matches an event, and the job handler that runs the queued ones.
+ *
+ * ```ts
+ * const flows = createFlows({
+ *   flows: [conversationToWorkItem()],
+ *   clients: (tenant) => blocksFor(tenant),
+ * });
+ * await outbox.consume("flows", flows.sink());
+ * ```
+ */
+export declare function createFlows<C extends FlowClients>(options: FlowsOptions<C>): Flows;
+//#endregion
+//#region src/flows/built-ins.d.ts
+type Created = PromiseLike<Result<{
+  readonly id: string;
+}>>;
+/** The subject types a built-in reads and writes, when the app renamed them. */
+interface BuiltInFlowOptions {
+  /** The event that starts the flow. */
+  readonly on?: string;
+  /** The subject type of the record the event is about. */
+  readonly sourceType?: string;
+  /** The subject type the flow creates. */
+  readonly targetType?: string;
+}
+/** `blocks.inbox` and `blocks.workItems`, for `conversationToWorkItem`. */
+interface ConversationToWorkItemClients extends FlowClients {
+  readonly inbox: {
+    readonly conversations: {
+      get(conversationId: string): PromiseLike<Result<Conversation | null>>;
+    };
+  };
+  readonly workItems: {
+    create(organizationId: string, input: WorkItemInput, assigneeIds?: readonly string[]): PromiseLike<Result<WorkItem>>;
+  };
+}
+interface ConversationToWorkItemOptions extends BuiltInFlowOptions {
+  /**
+   * The work item for a conversation. Default: its subject or preview as the
+   * title.
+   */
+  readonly map?: (conversation: Conversation, context: FlowContext<ConversationToWorkItemClients, InboxEventData>) => WorkItemInput;
+  /** Assigns the work item to the conversation's assignee. Default: true. */
+  readonly assign?: boolean;
+}
+/**
+ * A work item for each conversation the inbox opens, linked `created_from` the
+ * conversation. The mapped input passes the work item input schema.
+ */
+export declare function conversationToWorkItem(options?: ConversationToWorkItemOptions): Flow<ConversationToWorkItemClients, InboxEventData, Conversation, WorkItemInput>;
+/** `blocks.employees`, for `applicationToEmployee`. */
+interface ApplicationToEmployeeClients extends FlowClients {
+  readonly employees: {
+    fromApplication(applicationId: string, overrides?: Partial<EmployeeInput>): PromiseLike<Result<Employee>>;
+  };
+}
+interface ApplicationToEmployeeOptions extends BuiltInFlowOptions {
+  /** Overrides what the employee takes from the candidate and the job. */
+  readonly map?: (context: FlowContext<ApplicationToEmployeeClients, ApplicationEventData>) => Partial<EmployeeInput>;
+}
+/**
+ * An employee in preboarding for each hired application, through
+ * `employees.fromApplication`, which records the `created_from` link itself.
+ */
+export declare function applicationToEmployee(options?: ApplicationToEmployeeOptions): Flow<ApplicationToEmployeeClients, ApplicationEventData, undefined, Partial<EmployeeInput>>;
+/** `blocks.engagements`, for `bookingToEngagement`. */
+interface BookingToEngagementClients extends FlowClients {
+  readonly engagements: {
+    log(organizationId: string, input: EngagementInput & {
+      readonly type: string;
+      readonly title: string;
+    }, subjects: readonly EngagementSubject[]): PromiseLike<Result<Engagement>>;
+  };
+}
+/** The engagement `bookingToEngagement` logs. */
+type BookingEngagementInput = EngagementInput & {
+  readonly type: string;
+  readonly title: string;
+};
+interface BookingToEngagementOptions extends BuiltInFlowOptions {
+  /**
+   * The engagement for a booking. Default: a `meeting` titled after the
+   * booking.
+   */
+  readonly map?: (context: FlowContext<BookingToEngagementClients, SchedulingEventData>) => BookingEngagementInput;
+  /**
+   * The records the engagement is on besides the booking, such as the customer
+   * who booked.
+   */
+  readonly subjects?: (context: FlowContext<BookingToEngagementClients, SchedulingEventData>) => readonly EngagementSubject[];
+}
+/**
+ * A meeting engagement for each confirmed booking, on the booking. It logs with
+ * `externalRef: booking:<id>`, so a second log updates the same engagement.
+ */
+export declare function bookingToEngagement(options?: BookingToEngagementOptions): Flow<BookingToEngagementClients, SchedulingEventData, undefined, BookingEngagementInput>;
+interface QuoteToOrderOptions extends BuiltInFlowOptions {
+  /**
+   * Creates the order for an accepted quote and returns its id, such as a cart
+   * of the quote's variants and `orders.checkout`. The orders block has no
+   * conversion from a quote, so the app supplies it.
+   */
+  readonly create: (context: FlowContext<FlowClients, QuoteEventData>) => Created;
+}
+/**
+ * An order for each accepted quote, linked `created_from` the quote, so the
+ * quote's lineage shows the order and an accepted quote orders once.
+ */
+export declare function quoteToOrder(options: QuoteToOrderOptions): Flow<FlowClients, QuoteEventData, undefined, undefined>;
+//#endregion
+export type { AnyFlow, ApplicationToEmployeeClients, ApplicationToEmployeeOptions, BookingEngagementInput, BookingToEngagementClients, BookingToEngagementOptions, BuiltInFlowOptions, ConversationToWorkItemClients, ConversationToWorkItemOptions, Flow, FlowClients, FlowContext, FlowEvent, FlowJob, FlowOutcome, FlowRef, FlowRelations, FlowSpec, Flows, FlowsOptions, QuoteToOrderOptions };