better-supabase 0.14.0 → 0.15.0

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

@@ -0,0 +1,524 @@
+/// <reference lib="esnext.temporal" />
+import { D as ValidationIssue, T as ErrorMapper, b as DbError, f as Result, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { Ct as Events } from "../../events-vcqenSYU.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-DZN2w69m.js";
+import { _ as FilterRule, d as FilterLimits, f as FilterNode, h as FilterQuery, i as FilterCombinator, m as FilterOperatorSpec, r as FilterClock } from "../../filter-query-BXLs72G9.js";
+import { $t as createActionRegistry, Bt as Action, Gt as ActionInfo, Ht as ActionContext, Jt as ActionRegistry, Kt as ActionOrigin, L as NotifierInput, Qt as actionKey, Ut as ActionDescriptor, Vt as ActionCall, Wt as ActionHandler, Yt as ActionSpec, Zt as DefaultAutomation, c as BlockOf, en as defineAction, qt as ActionRef } from "../../define-block-BVcLQ3DF.js";
+import { n as Controller, t as AuthPort } from "../../controller-BrP0gn47.js";
+import { o as ApprovalRequestInput } from "../../approvals-Crutd4-o.js";
+import { n as FilterRecordField, t as FilterEvaluation } from "../../filter-evaluate-CPxeae5X.js";
+import { a as checkRuleConditions, c as ruleFilterFields, i as RuleFieldDefinition, n as RuleField, o as defineRuleFields, r as RuleFieldCatalog, s as ruleFilterFieldInfo, t as RULE_LIMITS } from "../../fields-C3q2ypnO.js";
+import { a as ConversionRelations, i as ConversionRef, n as ConversionContext, o as ConversionSpec, r as ConversionOutcome, s as defineConversionAction, t as ConversionClients } from "../../conversion-BAbucuXq.js";
+//#region src/blocks/automations/automations.d.ts
+/** What a rule runs when it matches: an action reference (ADR 0046). */
+type RuleAction = ActionRef;
+interface Rule {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly subjectType: string;
+  /** The event type the rule is tested on, such as `expense.submitted`. */
+  readonly trigger: string;
+  readonly name: string;
+  readonly description: string | undefined;
+  readonly conditions: FilterQuery;
+  readonly actions: readonly RuleAction[];
+  readonly enabled: boolean;
+  /** A match ends the evaluation, so later rules for the trigger don't run. */
+  readonly stopProcessing: boolean;
+  /** The rank key rules are tested in. */
+  readonly rank: string;
+  readonly version: number;
+  readonly createdBy: string | undefined;
+  readonly updatedBy: string | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+  /**
+   * The key of the default automation this rule copies (`rule_defaults`), or
+   * `undefined` for a rule the organization wrote. A default can't be removed;
+   * turn it off or `resetDefault` it.
+   */
+  readonly defaultKey: string | undefined;
+}
+/** `upsert`'s input: left-out keys keep their value on an existing rule. */
+interface RuleInput {
+  readonly id?: string;
+  /** The version the editor read; a newer stored one fails with `RULE_CONFLICT`. */
+  readonly version?: number;
+  /** Required for a new rule; it can't change later. */
+  readonly subjectType?: string;
+  readonly trigger?: string;
+  readonly name?: string;
+  readonly description?: string | null;
+  readonly conditions?: FilterQuery;
+  readonly actions?: readonly RuleAction[];
+  /** Turning a rule on takes `rules.publish`. */
+  readonly enabled?: boolean;
+  readonly stopProcessing?: boolean;
+}
+interface RuleVersion {
+  readonly ruleId: string;
+  readonly version: number;
+  readonly name: string;
+  readonly conditions: FilterQuery;
+  readonly actions: readonly RuleAction[];
+  readonly savedBy: string | undefined;
+  readonly savedAt: Temporal.Instant;
+}
+/** A rule that matched, with the truth of every condition and group by node id. */
+interface RuleMatch {
+  readonly rule: Rule;
+  readonly results: Readonly<Record<string, boolean | null>>;
+}
+/** One entry of a rule's evaluation log. */
+interface RuleEvaluationEntry {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly ruleId: string;
+  readonly version: number;
+  readonly subjectType: string;
+  readonly subjectId: string | undefined;
+  readonly trigger: string;
+  readonly matched: boolean;
+  readonly results: Readonly<Record<string, boolean | null>>;
+  readonly mode: "live" | "test";
+  readonly evaluatedBy: string | undefined;
+  readonly evaluatedAt: Temporal.Instant;
+}
+interface RuleListOptions {
+  readonly subjectType?: string;
+  readonly trigger?: string;
+  readonly enabled?: boolean;
+}
+/** What `matching` and `run` test: one subject, as the trigger event saw it. */
+interface RuleSubject {
+  readonly subjectType: string;
+  readonly trigger: string;
+  /**
+   * The record the field catalog's columns read, such as the expense row with
+   * its submitter.
+   */
+  readonly subject: Readonly<Record<string, unknown>>;
+  /** The IANA zone relative dates ("today") resolve in. Default `UTC`. */
+  readonly timeZone?: string;
+}
+interface AutomationsOptions extends BlockTemporalOptions {
+  /** The caller's transport (`rpcTransport(supabase)`). */
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema. Default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Automations>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+interface Automations {
+  /** The field catalog, for one subject type or all of them. */
+  fields(subjectType?: string): AsyncResult<readonly RuleField[]>;
+  /** The organization's rules in evaluation order (needs `rules.read`). */
+  list(organizationId: string, options?: RuleListOptions): AsyncResult<readonly Rule[]>;
+  /** `undefined` when the caller can't read a rule with this id. */
+  get(id: string): AsyncResult<Rule | undefined>;
+  /**
+   * Creates or changes a rule. `rules.edit` covers disabled rules; enabling a
+   * rule or changing an enabled one takes `rules.publish`.
+   */
+  upsert(organizationId: string, input: RuleInput): AsyncResult<Rule>;
+  /** Turns a rule on or off (needs `rules.publish`). */
+  setEnabled(id: string, enabled: boolean): AsyncResult<Rule>;
+  /** Moves a rule to a rank key from `rankBetween` over its neighbours. */
+  move(id: string, rank: string): AsyncResult<Rule>;
+  /**
+   * Removes a rule with its history (needs `rules.admin`); `false` when there
+   * is none to remove. A default automation fails with `RULE_DEFAULT`; turn it
+   * off instead.
+   */
+  remove(id: string): AsyncResult<boolean>;
+  /**
+   * Restores a default automation to what its block ships (needs `rules.edit`,
+   * or `rules.publish` when it is or becomes enabled).
+   */
+  resetDefault(id: string): AsyncResult<Rule>;
+  /** Saved versions, newest first. */
+  versions(id: string): AsyncResult<readonly RuleVersion[]>;
+  /** The evaluation log, newest first. */
+  evaluations(id: string, options?: {
+    readonly before?: Temporal.Instant;
+    readonly pageSize?: number;
+  }): AsyncResult<readonly RuleEvaluationEntry[]>;
+  /** The enabled rules for the trigger that match, evaluated in the database. */
+  matching(organizationId: string, input: RuleSubject): AsyncResult<readonly RuleMatch[]>;
+  /**
+   * Runs a rule's stored conditions on a sample record and logs it as a test
+   * (needs `rules.edit`). Nothing runs; the result says what would match.
+   */
+  test(rule: Rule, subject: Readonly<Record<string, unknown>>, options?: {
+    readonly fields?: readonly RuleField[];
+    readonly subjectId?: string;
+    readonly clock?: FilterClock;
+  }): AsyncResult<FilterEvaluation>;
+}
+/** A rule row from the module's functions. */
+export declare function ruleOf(value: unknown): Rule;
+/** Catalog fields in the shape `evaluateFilterQuery` reads. */
+export declare function ruleRecordFields(fields: readonly RuleField[]): readonly FilterRecordField[];
+/**
+ * Tests a rule's conditions on one record in memory, the same way the
+ * database's `rule_evaluate` does. `fields` is the subject type's catalog.
+ */
+export declare function evaluateRule(rule: Pick<Rule, "conditions">, subject: unknown, fields: readonly RuleField[], clock?: FilterClock): FilterEvaluation;
+/** Tenant rules as the caller: the catalog, the rules, their history and tests. */
+export declare function createAutomations(options: AutomationsOptions): Automations;
+/**
+ * What `run` tests: like `RuleSubject`, with a null subject type for every rule
+ * of the trigger.
+ */
+interface RuleRun extends Omit<RuleSubject, "subjectType"> {
+  /** `null` tests every rule for the trigger, each on its own fields. */
+  readonly subjectType: string | null;
+  readonly subjectId?: string;
+}
+interface RulesAdminOptions extends BlockTemporalOptions {
+  /**
+   * A service-role transport: `sync_rule_fields` and `run_rules` are granted to
+   * `service_role` only.
+   */
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface AutomationsAdmin {
+  /** Replaces the subject type's field catalog; returns how many fields it has. */
+  syncFields(catalog: RuleFieldCatalog): AsyncResult<number>;
+  /**
+   * Evaluates the enabled rules for the trigger, logs each one live and returns
+   * the matches.
+   */
+  run(organizationId: string, input: RuleRun): AsyncResult<readonly RuleMatch[]>;
+}
+/** The field sync and live evaluation, with a service-role client. */
+export declare function createAutomationsAdmin(options: RulesAdminOptions): AutomationsAdmin;
+/** The outcome of one action: its value, or the error its action returned. */
+type RuleActionOutcome = {
+  readonly ruleId: string;
+  readonly kind: string;
+  readonly ok: true;
+  readonly value: unknown;
+} | {
+  readonly ruleId: string;
+  readonly kind: string;
+  readonly ok: false;
+  readonly error: DbError;
+};
+interface RuleDispatcherOptions {
+  /**
+   * The actions of every installed block (`createActionRegistry`), the same
+   * registry workflow and sequence steps run.
+   */
+  readonly actions: ActionRegistry;
+}
+interface RuleDispatcher {
+  /**
+   * Runs the actions of `matches` in order. A failed action doesn't stop the
+   * others; each one's outcome comes back. A kind no registered action handles
+   * is an `invalid_request` outcome with the hint `ACTION_UNKNOWN`. An empty
+   * `subjectType` in `context` takes each rule's.
+   */
+  dispatch(matches: readonly RuleMatch[], context: ActionContext): AsyncResult<readonly RuleActionOutcome[]>;
+}
+/** Runs matched rules' actions through the action registry. */
+export declare function createRuleDispatcher(options: RuleDispatcherOptions): RuleDispatcher;
+/** An outbox event as the rule sink reads it; an `OutboxEvent` fits. */
+interface RuleSinkEvent {
+  readonly id: string;
+  readonly type: string;
+  readonly payload?: unknown;
+  /** The CloudEvents subject, such as `conversations/<id>`. */
+  readonly subject?: string | null;
+  readonly tenant?: string | null;
+}
+/**
+ * What `load` returns for an event the rules should see: the subject and the
+ * action context.
+ */
+interface RuleSinkTarget {
+  readonly organizationId: string;
+  /** The subject type whose rules run. Absent: every rule for the trigger. */
+  readonly subjectType?: string;
+  readonly subjectId?: string;
+  /** The record the field catalog's columns read. */
+  readonly subject: Readonly<Record<string, unknown>>;
+  readonly timeZone?: string;
+  /** Default: built from the target and the event. */
+  readonly context?: ActionContext;
+}
+interface RuleSinkOptions {
+  /** `rules.run` from `createAutomationsAdmin`, which logs each evaluation live. */
+  readonly rules: Pick<AutomationsAdmin, "run">;
+  readonly dispatcher: RuleDispatcher;
+  /**
+   * Reads the subject an event is about, such as the app table row named by
+   * `payload.id`. `undefined`, or no `load`, falls back to the event itself
+   * (`eventTarget`), which is what the automations blocks ship test.
+   */
+  readonly load?: (event: RuleSinkEvent) => RuleSinkTarget | undefined | PromiseLike<RuleSinkTarget | undefined>;
+  /** Receives each event's action outcomes, failed ones included. */
+  readonly onOutcomes?: (event: RuleSinkEvent, outcomes: readonly RuleActionOutcome[]) => void;
+}
+/**
+ * The target for an event no `load` reads: the organization from the outbox
+ * tenant or `payload.organizationId`, the id from the CloudEvents subject
+ * (`conversations/<id>`) or `payload.id`, and the payload as the subject. Every
+ * rule for the trigger runs. `undefined` for an event without an organization.
+ */
+export declare function eventTarget(event: RuleSinkEvent): RuleSinkTarget | undefined;
+/**
+ * An outbox consumer handler that tests the rules whose trigger is the event's
+ * type and runs the actions of the ones that match, for
+ * `outbox.consume("rules", createRuleSink(...))`. It throws when the evaluation
+ * fails, so the outbox retries the event; a failed action goes to `onOutcomes`
+ * instead, since a retry would run the others again.
+ */
+export declare function createRuleSink(options: RuleSinkOptions): (events: readonly RuleSinkEvent[]) => Promise<void>;
+//#endregion
+//#region src/blocks/automations/client.d.ts
+interface RuleBuilderControllerOptions {
+  readonly client: Pick<Automations, "fields" | "get" | "upsert">;
+  readonly auth: AuthPort;
+  readonly organizationId: string;
+  /** The rule to edit; `null` edits a new one. */
+  readonly rule: string | null;
+  /** The record type whose fields the rules test. */
+  readonly subjectType: string;
+  /** A new rule's trigger, such as `expense.submitted`. */
+  readonly trigger?: string;
+  /** The tree a new rule starts with, such as a fixed first condition. */
+  readonly initial?: FilterQuery;
+  /**
+   * Node ids the editor may not change, move or remove, such as the fixed first
+   * condition. Only the editor knows them; the stored rule doesn't.
+   */
+  readonly locked?: readonly string[];
+  /** Defaults to `RULE_LIMITS`. */
+  readonly limits?: FilterLimits;
+  /** Makes node ids. Defaults to `crypto.randomUUID()`. */
+  readonly newId?: () => string;
+}
+interface RuleBuilderSnapshot {
+  /** The stored rule; `undefined` for a new one or before the first load. */
+  readonly rule: Rule | undefined;
+  /** The subject type's field catalog; `undefined` until loaded. */
+  readonly fields: readonly RuleField[] | undefined;
+  readonly name: string;
+  readonly conditions: FilterQuery;
+  readonly actions: readonly RuleAction[];
+  readonly stopProcessing: boolean;
+  readonly locked: readonly string[];
+  /** Problems in the tree, checked against the fields once they load. */
+  readonly issues: readonly ValidationIssue[];
+  /**
+   * Whether the name, tree, actions or `stopProcessing` differ from the stored
+   * rule.
+   */
+  readonly dirty: boolean;
+  readonly loading: boolean;
+  readonly saving: boolean;
+  readonly error: DbError | undefined;
+}
+interface RuleBuilderActions {
+  /** Loads the fields and the rule again, dropping unsaved edits. */
+  readonly refresh: () => Promise<void>;
+  /** Adds a condition to `group` (the root by default) and returns its id. */
+  readonly addRule: (group?: string, field?: string) => string;
+  /** Adds an empty group to `group` (the root by default) and returns its id. */
+  readonly addGroup: (group?: string, combinator?: FilterCombinator) => string;
+  readonly remove: (id: string) => void;
+  /** Moves a node into `group`, where it ends up at `index`. */
+  readonly move: (id: string, group: string, index: number) => void;
+  readonly setField: (id: string, field: string) => void;
+  /** Keeps the value when the operator takes the same kind of value. */
+  readonly setOperator: (id: string, operator: string) => void;
+  readonly setValue: (id: string, value: unknown) => void;
+  readonly setNegated: (id: string, negated: boolean) => void;
+  readonly setCombinator: (group: string, combinator: FilterCombinator) => void;
+  readonly setName: (name: string) => void;
+  readonly setActions: (actions: readonly RuleAction[]) => void;
+  readonly setStopProcessing: (stop: boolean) => void;
+  readonly lock: (id: string) => void;
+  readonly unlock: (id: string) => void;
+  /** Drops unsaved edits. */
+  readonly reset: () => void;
+  /**
+   * Saves the rule, `enabled` turning it on or off with it. The saved rule, or
+   * `undefined` with `error` set.
+   */
+  readonly save: (options?: {
+    readonly enabled?: boolean;
+  }) => Promise<Rule | undefined>;
+}
+type RuleBuilderController = Controller<RuleBuilderSnapshot, RuleBuilderActions>;
+/**
+ * The editor state of one rule: the field catalog, the condition tree and the
+ * edits to it, with validation, dirty state and save.
+ */
+export declare function createRuleBuilderController(options: RuleBuilderControllerOptions): RuleBuilderController;
+//#endregion
+//#region src/blocks/automations/tree.d.ts
+/** The operators a field allows, in the order the editor lists them. */
+export declare function ruleOperators(field: RuleField): readonly FilterOperatorSpec[];
+/** An empty `and` group, the tree a new rule starts with. */
+export declare const emptyConditions: (id?: string) => FilterQuery;
+/** The node with `id`, or `undefined`. */
+export declare function findNode(tree: FilterNode, id: string): FilterNode | undefined;
+/** The group that holds `id`, or `undefined` for the root and unknown ids. */
+export declare function parentOf(tree: FilterQuery, id: string): FilterQuery | undefined;
+/** Whether `id` is `ancestor` or sits anywhere under it. */
+export declare function contains(ancestor: FilterNode, id: string): boolean;
+/** Replaces the node with `id` by what `change` returns. */
+export declare function updateNode(tree: FilterQuery, id: string, change: (node: FilterNode) => FilterNode): FilterQuery;
+/** Drops the node with `id` and everything under it; the root stays. */
+export declare function removeNode(tree: FilterQuery, id: string): FilterQuery;
+/**
+ * Adds `node` to the group `parent` at `index` (the end by default). Unchanged
+ * when `parent` isn't a group in the tree.
+ */
+export declare function insertNode(tree: FilterQuery, parent: string, node: FilterNode, index?: number): FilterQuery;
+/**
+ * Moves the node with `id` into the group `parent`, where it ends up at `index`
+ * (as `arrayMove` counts it). Unchanged for the root, an unknown node or group,
+ * or a move into the node itself.
+ */
+export declare function moveNode(tree: FilterQuery, id: string, parent: string, index: number): FilterQuery;
+/** Changes a group's `and` or `or`. */
+export declare function setCombinator(tree: FilterQuery, id: string, combinator: FilterCombinator): FilterQuery;
+/**
+ * Points a rule at another field. A field of the same type keeps the operator
+ * it allows, and its value; another type starts at the field's first operator
+ * without a value.
+ */
+export declare function setRuleField(rule: FilterRule, field: RuleField, previous: RuleField | undefined): FilterRule;
+/**
+ * Changes a rule's operator. The value stays when the new operator takes the
+ * same kind of value (one, many or a range), and is dropped otherwise.
+ */
+export declare function setRuleOperator(rule: FilterRule, operator: string, field: RuleField | undefined): FilterRule;
+//#endregion
+//#region src/blocks/automations/actions.d.ts
+/** The record and event an action runs for. */
+type RuleSubjectContext = ActionContext;
+/**
+ * The part of the approvals client the action calls. Its tenant must be the
+ * context's `organizationId`.
+ */
+interface RuleApprovals {
+  request(subject: RecordRef, input: ApprovalRequestInput): AsyncResult<unknown>;
+}
+/**
+ * The `approvals.request` action: starts an approval of the subject for the
+ * action in `config.action`, such as `{ kind: "approvals.request", config: {
+ * action: "manager_review" } }`.
+ */
+export declare function approvalsAction(approvals: RuleApprovals): Action;
+/** The part of a `notifier` port (the notifications block) the action calls. */
+interface RuleNotifier {
+  send(type: string, input: NotifierInput): unknown;
+}
+/**
+ * The `notify` action: sends the notification type in `config.type` to the user
+ * ids in `config.recipients` and in the payload column that
+ * `config.recipientField` names, with `config.data` and the payload as its
+ * data: `{ kind: "notify", config: { type: "task.assigned", recipientField:
+ * "assignee_id" } }`.
+ */
+export declare function notifyAction(notifier: RuleNotifier): Action;
+/** What `setFieldAction` asks the app to write: one column of the subject's row. */
+interface RuleFieldWrite {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly field: string;
+  readonly value: unknown;
+}
+/** Writes one field, such as through an app table repository's `update`. */
+type RuleFieldSetter = (write: RuleFieldWrite) => Result<unknown> | PromiseLike<Result<unknown>>;
+/**
+ * The `set_field` action: writes `config.value` to the subject's
+ * `config.field`: `{ kind: "set_field", config: { field: "status", value:
+ * "review" } }`. The setter decides which fields it accepts.
+ */
+export declare function setFieldAction(setField: RuleFieldSetter): Action;
+/** The part of the outgoing webhooks client the action calls. */
+interface RuleWebhooks {
+  dispatch(input: {
+    readonly endpointId: string;
+    readonly type: string;
+    readonly data: unknown;
+    readonly eventId?: string;
+  }): AsyncResult<string>;
+}
+/**
+ * The `webhook` action: queues a delivery to the endpoint in
+ * `config.endpointId`, typed `config.type` or the trigger, with the payload as
+ * its data: `{ kind: "webhook", config: { endpointId: "..." } }`.
+ */
+export declare function webhookAction(webhooks: RuleWebhooks): Action;
+/** The part of the workflow editor client the action calls. */
+interface RuleWorkflows {
+  run(input: {
+    readonly definition: string;
+    readonly input?: unknown;
+    readonly idempotencyKey?: string;
+    readonly subject?: {
+      readonly type: string;
+      readonly id: string;
+    };
+    readonly tenant?: string;
+  }): AsyncResult<string>;
+}
+/**
+ * The `workflow` action: starts the workflow definition in `config.definition`
+ * on the subject, with the payload as its input: `{ kind: "workflow", config: {
+ * definition: "..." } }`. Workflows start only this way, so a retried event
+ * starts no second run.
+ */
+export declare function workflowAction(workflows: RuleWorkflows): Action;
+//#endregion
+//#region src/blocks/automations/events.d.ts
+/** `rule.saved`, `rule.enabled`, `rule.disabled` and `rule.removed`. */
+interface RuleEventData {
+  readonly organizationId: string;
+  readonly ruleId: string;
+  readonly name: string;
+  readonly subjectType: string;
+  readonly trigger: string;
+  readonly version: number;
+}
+/** `rule.matched`: a live evaluation matched a subject. */
+interface RuleMatchedEventData {
+  readonly organizationId: string;
+  readonly ruleId: string;
+  readonly version: number;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly trigger: string;
+}
+/** The events of the `rules` block: type to data. */
+type AutomationsEvents = {
+  readonly "rule.saved": RuleEventData;
+  readonly "rule.enabled": RuleEventData;
+  readonly "rule.disabled": RuleEventData;
+  readonly "rule.removed": RuleEventData;
+  readonly "rule.matched": RuleMatchedEventData;
+};
+/** The `rules` block's event types, for its manifest and `onBlockEvent`. */
+export declare const automationsEvents: Events<AutomationsEvents>;
+//#endregion
+//#region src/blocks/automations/manifest.d.ts
+/** The `automations` block's manifest (ADR 0029). */
+export declare const automationsBlock: BlockOf<"automations", typeof createAutomations, AutomationsEvents>;
+//#endregion
+export { type Action, type ActionCall, type ActionContext, type ActionDescriptor, type ActionHandler, type ActionInfo, type ActionOrigin, type ActionRef, type ActionRegistry, type ActionSpec, type Automations, type AutomationsAdmin, type AutomationsEvents, type AutomationsOptions, type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type ConversionClients, type ConversionContext, type ConversionOutcome, type ConversionRef, type ConversionRelations, type ConversionSpec, type DefaultAutomation, RULE_LIMITS, type RpcClient, type Rule, type RuleAction, type RuleActionOutcome, type RuleApprovals, type RuleBuilderActions, type RuleBuilderController, type RuleBuilderControllerOptions, type RuleBuilderSnapshot, type RuleDispatcher, type RuleDispatcherOptions, type RuleEvaluationEntry, type RuleEventData, type RuleField, type RuleFieldCatalog, type RuleFieldDefinition, type RuleFieldSetter, type RuleFieldWrite, type RuleInput, type RuleListOptions, type RuleMatch, type RuleMatchedEventData, type RuleNotifier, type RuleRun, type RuleSinkEvent, type RuleSinkOptions, type RuleSinkTarget, type RuleSubject, type RuleSubjectContext, type RuleVersion, type RuleWebhooks, type RuleWorkflows, type RulesAdminOptions, actionKey, checkRuleConditions, createActionRegistry, dbTransport, defineAction, defineConversionAction, defineRuleFields, extendBlock, rpcTransport, ruleFilterFieldInfo, ruleFilterFields, sqlTransport, withBlockHooks, wrapTransport };