better-supabase 0.13.0 → 0.14.0

package/dist/employees-Dwyvxs4r.d.ts

@@ -0,0 +1,180 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
+import { r as FieldsOf } from "./block-fields-3w4MZr8U.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "./block-helpers-BaugZlJV.js";
+import { t as BlockTransport } from "./block-transport-d53POsem.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+import { n as Money } from "./money-BNRdJQzA.js";
+import { t as RecordRef } from "./sales-shared-DAAGwQwN.js";
+//#region src/blocks/employees/employees.d.ts
+type EmployeeStatus = "preboarding" | "active" | "on_leave" | "offboarded";
+type SalaryPeriod = "hour" | "week" | "month" | "year";
+/** An employee. `F` types the extra columns the `fields` schema describes. */
+interface Employee<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly name: string;
+  readonly email?: string;
+  /**
+   * The account, when the employee has one; contractors and interns often
+   * don't.
+   */
+  readonly userId?: string;
+  readonly jobTitle?: string;
+  readonly teamId?: string;
+  readonly managerId?: string;
+  readonly employmentType?: string;
+  readonly status: EmployeeStatus;
+  readonly startDate?: Temporal.PlainDate;
+  readonly endDate?: Temporal.PlainDate;
+  readonly offboardReason?: string;
+  /** The record it was made from, such as `{ type: "application", id }`. */
+  readonly origin?: RecordRef;
+  readonly createdAt?: Temporal.Instant;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: Readonly<Record<string, unknown>> & F;
+}
+/** An employee in the org chart or a manager's reports. */
+interface OrgChartEntry<F extends object = Record<never, never>> extends Employee<F> {
+  /** 0 for a root of the chart, 1 for a direct report. */
+  readonly depth: number;
+  readonly directReports: number;
+}
+interface EmployeeInput<F extends object = Record<never, never>> {
+  readonly name: string;
+  readonly email?: string;
+  readonly userId?: string;
+  readonly jobTitle?: string;
+  readonly teamId?: string;
+  readonly managerId?: string;
+  /** One of `options.employmentTypes`; the first one by default. */
+  readonly employmentType?: string;
+  /** Preboarding before the start date and active from it, by default. */
+  readonly status?: Exclude<EmployeeStatus, "offboarded">;
+  readonly startDate?: Temporal.PlainDate;
+  readonly endDate?: Temporal.PlainDate;
+  /** With an origin, creating again returns the same employee. */
+  readonly origin?: RecordRef;
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+type EmployeeField = "name" | "email" | "userId" | "jobTitle" | "teamId" | "managerId" | "employmentType" | "status" | "startDate" | "endDate";
+/** One cell edit: a field above, or an extra column by name. `null` clears it. */
+interface EmployeeChange {
+  readonly employeeId: string;
+  readonly field: EmployeeField | (string & {});
+  readonly value: unknown;
+}
+interface EmployeeChangeResult {
+  readonly accepted: readonly {
+    readonly employeeId: string;
+    readonly field: string;
+  }[];
+  /** Each refused change, with the error hint and message. Others still applied. */
+  readonly rejected: readonly {
+    readonly employeeId: string;
+    readonly field: string;
+    readonly hint?: string;
+    readonly reason: string;
+  }[];
+}
+interface EmergencyContact {
+  readonly name: string;
+  readonly phone?: string;
+  readonly relation?: string;
+}
+interface PrivateDetails {
+  readonly employeeId: string;
+  readonly nationalId?: string;
+  readonly iban?: string;
+  readonly birthDate?: Temporal.PlainDate;
+  readonly personalEmail?: string;
+  readonly phone?: string;
+  readonly address?: Readonly<Record<string, unknown>>;
+  readonly emergencyContacts: readonly EmergencyContact[];
+  /** Set on offboarding, so an anonymize rule can start from it. */
+  readonly offboardedAt?: Temporal.Instant;
+  readonly anonymizedAt?: Temporal.Instant;
+}
+/** The details to save. Left out keeps the stored value; `null` clears it. */
+interface PrivateDetailsInput {
+  readonly nationalId?: string | null;
+  readonly iban?: string | null;
+  readonly birthDate?: Temporal.PlainDate | null;
+  readonly personalEmail?: string | null;
+  readonly phone?: string | null;
+  readonly address?: Readonly<Record<string, unknown>> | null;
+  readonly emergencyContacts?: readonly EmergencyContact[] | null;
+}
+/** A contract. */
+interface Contract {
+  readonly id: string;
+  readonly employeeId: string;
+  readonly startsOn: Temporal.PlainDate;
+  readonly endsOn?: Temporal.PlainDate;
+  readonly hoursPerWeek?: number;
+  readonly salary?: Money;
+  readonly salaryPeriod?: SalaryPeriod;
+  readonly note?: string;
+}
+interface ContractInput {
+  readonly startsOn: Temporal.PlainDate;
+  readonly endsOn?: Temporal.PlainDate;
+  readonly hoursPerWeek?: number;
+  readonly salary?: Money;
+  readonly salaryPeriod?: SalaryPeriod;
+  readonly note?: string;
+}
+interface Employees<F extends object = Record<never, never>> {
+  create(organizationId: string, input: EmployeeInput<F>): AsyncResult<Employee<F>>;
+  /** Applies each change on its own; one that fails doesn't stop the others. */
+  update(changes: readonly EmployeeChange[]): AsyncResult<EmployeeChangeResult>;
+  /**
+   * Sets the end date (today by default) and moves the reports to the
+   * employee's manager.
+   */
+  offboard(employeeId: string, options?: {
+    readonly endDate?: Temporal.PlainDate;
+    readonly reason?: string;
+  }): AsyncResult<Employee<F>>;
+  /** The chart under `rootId`, or under everyone without a manager. */
+  orgChart(organizationId: string, rootId?: string): AsyncResult<readonly OrgChartEntry<F>[]>;
+  /** Direct reports, or everyone under the manager with `indirect`. */
+  reportsOf(managerId: string, options?: {
+    readonly indirect?: boolean;
+  }): AsyncResult<readonly OrgChartEntry<F>[]>;
+  /**
+   * The employee for a hired application (the hiring module), in preboarding,
+   * made once. `overrides` replaces what the candidate and the job give.
+   */
+  fromApplication(applicationId: string, overrides?: Partial<EmployeeInput<F>>): AsyncResult<Employee<F>>;
+  /** Needs employees.view_sensitive, or being the employee. */
+  privateDetails(employeeId: string): AsyncResult<PrivateDetails | undefined>;
+  savePrivateDetails(employeeId: string, input: PrivateDetailsInput): AsyncResult<PrivateDetails>;
+  /** The newest first. */
+  contracts(employeeId: string): AsyncResult<readonly Contract[]>;
+  /** Starts after the latest contract, which ends the day before. */
+  addContract(employeeId: string, input: ContractInput): AsyncResult<Contract>;
+}
+interface EmployeesOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the extra columns
+   * (`blocks.employees.options.extraColumns`), keyed by column name. It types
+   * and parses `fields` on reads and validates them on writes.
+   */
+  readonly fields?: S;
+  readonly hooks?: NoInfer<BlockHooks<Employees<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The employees block: the people an organization employs, their manager, team
+ * and status, the org chart, offboarding, and private details and contracts
+ * behind employees.view_sensitive.
+ */
+declare function createEmployees<S extends StandardSchemaV1 | undefined = undefined>(options: EmployeesOptions<S>): Employees<FieldsOf<S>>;
+//#endregion
+export { EmployeeChange as a, EmployeeInput as c, EmployeesOptions as d, OrgChartEntry as f, createEmployees as g, SalaryPeriod as h, Employee as i, EmployeeStatus as l, PrivateDetailsInput as m, ContractInput as n, EmployeeChangeResult as o, PrivateDetails as p, EmergencyContact as r, EmployeeField as s, Contract as t, Employees as u };

package/dist/ended--Bd_Q6uL.d.ts

@@ -0,0 +1,76 @@
+import { m as RequestContext } from "./plugin-Ar5546xh.js";
+import { g as StoredSession, r as AuthState, u as CookieOptions } from "./resolve-CzUKTIMq.js";
+//#region src/auth/refresh.d.ts
+interface RefreshOptions {
+  readonly url: string;
+  readonly publishableKey: string;
+  /**
+   * Sends `Sb-Forwarded-For: ip` with the secret key, so Auth rate-limits the
+   * refresh by the user's IP (when IP forwarding is on for the project).
+   */
+  readonly forwardedFor?: {
+    readonly ip: string;
+    readonly secretKey: string;
+  };
+  readonly fetch?: typeof fetch;
+  /**
+   * Milliseconds before a refresh counts as a network failure (the session is
+   * kept). 5000 by default.
+   */
+  readonly timeoutMs?: number;
+  /** Epoch milliseconds, the unit JWT `exp` and `iat` math needs. */
+  readonly now?: () => number;
+}
+type RefreshOutcome = {
+  readonly ok: true;
+  readonly session: StoredSession;
+  /** Served from a concurrent or just-finished refresh of the same token. */
+  readonly shared?: boolean;
+} | {
+  readonly ok: false;
+  /**
+   * `rejected`: the refresh token is dead, sign the user out. `network`:
+   * keep the session and retry later.
+   */
+  readonly reason: "rejected" | "network";
+  /** For `network`: the fetch failed, timed out, or Auth answered 5xx or 429. */
+  readonly cause?: "fetch" | "timeout" | "status";
+  readonly status?: number;
+  /**
+   * The Auth server's `error_code`, such as `user_banned` or
+   * `refresh_token_not_found`.
+   */
+  readonly code?: string;
+  readonly message: string;
+};
+/**
+ * Exchanges a refresh token for a new session. Concurrent calls with the same
+ * token share one request, and a successful result is reused for a short window
+ * so parallel requests carrying the old cookie converge on one session.
+ */
+declare function refreshSession(refreshToken: string, options: RefreshOptions): Promise<RefreshOutcome>;
+//#endregion
+//#region src/auth/context.d.ts
+/** The repository context (`actor`, `claims`) for an auth state. */
+declare function authContext(auth: AuthState): RequestContext;
+//#endregion
+//#region src/auth/ended.d.ts
+/** `banned`: Auth rejected the token with `error_code: "user_banned"`. */
+type SessionStatus = "active" | "ended" | "banned" | "unknown";
+interface SessionStatusOptions {
+  readonly url: string;
+  readonly publishableKey: string;
+  readonly cookieName?: string;
+  readonly fetch?: typeof fetch;
+  readonly timeoutMs?: number;
+  readonly now?: () => number;
+}
+interface ClearSessionCookiesOptions {
+  readonly url: string;
+  readonly cookieName?: string;
+  readonly cookie?: CookieOptions;
+}
+declare function sessionStatus(input: Request | string, options: SessionStatusOptions): Promise<SessionStatus>;
+declare function clearSessionCookies<R extends Response>(request: Request, response: R, options: ClearSessionCookiesOptions): R;
+//#endregion
+export { sessionStatus as a, RefreshOutcome as c, clearSessionCookies as i, refreshSession as l, SessionStatus as n, authContext as o, SessionStatusOptions as r, RefreshOptions as s, ClearSessionCookiesOptions as t };

package/dist/engagements-CsJhf2OM.d.ts

@@ -0,0 +1,179 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
+import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
+import { r as FieldsOf } from "./block-fields-3w4MZr8U.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "./block-helpers-BaugZlJV.js";
+import { t as BlockTransport } from "./block-transport-d53POsem.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+import { f as AiFiles } from "./types-BEDfwXL4.js";
+import { g as JobHandler } from "./types-CGUDoF5I.js";
+import { a as EngagementRecording, d as Transcript, f as TranscriptSegment, i as EngagementNotesInput, l as Transcriber, r as EngagementNotes, s as NoteTaker } from "./recordings-DgDu7AOt.js";
+//#region src/blocks/engagements/engagements.d.ts
+/** A record an engagement is on. */
+interface EngagementSubject {
+  readonly type: string;
+  readonly id: string;
+}
+/** A call, email, meeting, note or task logged on one or more records. */
+interface Engagement<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  /** `call`, `email`, `meeting`, `note`, `task` or a configured type. */
+  readonly type: string;
+  readonly title: string;
+  readonly body?: string;
+  /** How it went, such as `connected`, `no_answer` or `replied`. */
+  readonly outcome?: string;
+  readonly ownerId?: string;
+  readonly dueAt?: Temporal.Instant;
+  readonly doneAt?: Temporal.Instant;
+  readonly durationSeconds?: number;
+  /** The id in the system it came from, such as a mail or calendar provider. */
+  readonly externalRef?: string;
+  /** The records it is on; the first is its main record. */
+  readonly subjects: readonly EngagementSubject[];
+  /** Open and past its due time. */
+  readonly overdue: boolean;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: Readonly<Record<string, unknown>> & F;
+}
+/**
+ * The fields of a write. On update, left out keeps the value and `null` clears
+ * it.
+ */
+interface EngagementInput<F extends object = Record<never, never>> {
+  readonly type?: string;
+  readonly title?: string;
+  readonly body?: string | null;
+  readonly outcome?: string | null;
+  /** Defaults to the caller on `log`. */
+  readonly ownerId?: string | null;
+  readonly dueAt?: Temporal.Instant | null;
+  readonly doneAt?: Temporal.Instant | null;
+  readonly durationSeconds?: number | null;
+  /** Logging the same `externalRef` again updates the engagement. */
+  readonly externalRef?: string | null;
+  /** Values for the extra columns, by column name. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+/** `F` types the engagements' extra columns, from the `fields` schema. */
+interface Engagements<F extends object = Record<never, never>> {
+  /**
+   * Logs an engagement on the records in `subjects`, the first being its main
+   * record.
+   */
+  log(organizationId: string, input: EngagementInput<F> & {
+    readonly type: string;
+    readonly title: string;
+  }, subjects: readonly EngagementSubject[]): AsyncResult<Engagement<F>>;
+  /** Changes an engagement, and its records when `subjects` is given. */
+  update(id: string, input: EngagementInput<F>, subjects?: readonly EngagementSubject[]): AsyncResult<Engagement<F>>;
+  /** Marks it done now, with an outcome, or open again with `done: false`. */
+  complete(id: string, options?: {
+    readonly done?: boolean;
+    readonly outcome?: string;
+  }): AsyncResult<Engagement<F>>;
+  remove(id: string): AsyncResult<boolean>;
+  /** A record's engagements, newest first (50 by default, at most 200). */
+  of(subject: EngagementSubject, options?: {
+    readonly types?: readonly string[];
+    readonly before?: Temporal.Instant;
+    readonly limit?: number;
+  }): AsyncResult<Engagement<F>[]>;
+  /** The next open engagement with a due time on a record, or `undefined`. */
+  next(subject: EngagementSubject): AsyncResult<Engagement<F> | undefined>;
+  /** A member's open engagements, earliest due first. Default: the caller's. */
+  open(organizationId: string, options?: {
+    readonly ownerId?: string;
+    readonly dueBefore?: Temporal.Instant;
+    readonly limit?: number;
+  }): AsyncResult<Engagement<F>[]>;
+  /**
+   * Attaches a ready ai-files file as a call or meeting recording
+   * (`options.recordings`). With the jobs block it queues a transcription on
+   * `engagements.transcribe`.
+   */
+  attachRecording(engagementId: string, fileId: string, options?: {
+    readonly language?: string;
+  }): AsyncResult<EngagementRecording>;
+  /** An engagement's recordings, oldest first. */
+  recordings(engagementId: string): AsyncResult<EngagementRecording[]>;
+  /** A recording's speaker turns in order (500 by default, at most 5000). */
+  transcript(recordingId: string, options?: {
+    readonly after?: number;
+    readonly limit?: number;
+  }): AsyncResult<TranscriptSegment[]>;
+  /** Replaces a recording's transcript, from a transcriber or an import. */
+  saveTranscript(recordingId: string, transcript: Transcript & {
+    readonly model?: string;
+  }): AsyncResult<EngagementRecording>;
+  /**
+   * Transcribes a recording with `transcriber`, reading the file through
+   * `files`, and saves the result. Runs on `service` when given.
+   */
+  transcribe(recordingId: string, options?: {
+    readonly signal?: AbortSignal;
+  }): AsyncResult<EngagementRecording>;
+  /**
+   * The handler for the `engagements.transcribe` queue. The last attempt marks
+   * the recording failed with the error.
+   */
+  transcribeJob(): JobHandler<{
+    readonly recordingId: string;
+  }>;
+  /**
+   * Transcribes pending recordings without a queue (service role). Returns how
+   * many succeeded; a failure marks its recording failed.
+   */
+  drainRecordings(options?: {
+    readonly batch?: number;
+    readonly signal?: AbortSignal;
+  }): AsyncResult<number>;
+  /** The engagement's notes, or `undefined`. */
+  notes(engagementId: string): AsyncResult<EngagementNotes | undefined>;
+  /** Saves notes a member wrote, replacing earlier ones. */
+  saveNotes(engagementId: string, notes: EngagementNotesInput): AsyncResult<EngagementNotes>;
+  /**
+   * Writes the engagement's notes with `noteTaker` from its transcripts and
+   * saves them.
+   */
+  summarize(engagementId: string, options?: {
+    readonly signal?: AbortSignal;
+  }): AsyncResult<EngagementNotes>;
+}
+interface EngagementsOptions<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 engagements' extra columns
+   * (`blocks.engagements.options.extraColumns`), keyed by column name. It types
+   * and parses `fields` on reads and validates them on writes.
+   */
+  readonly fields?: S;
+  readonly hooks?: NoInfer<BlockHooks<Engagements<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+  /** Calls as the service role, for `transcribe`, its job and the drain. */
+  readonly service?: BlockTransport;
+  /** The ai-files block, which `transcribe` reads recordings through. */
+  readonly files?: AiFiles;
+  /** Turns recordings into transcripts, for `transcribe`. */
+  readonly transcriber?: Transcriber;
+  /** Writes notes from transcripts, for `summarize`. */
+  readonly noteTaker?: NoteTaker;
+}
+/**
+ * The engagements block: calls, emails, meetings, notes and tasks on any record
+ * registered in `config.subjects`, for a record's activity panel, a "next step"
+ * and a member's task list.
+ */
+declare function createEngagements<S extends StandardSchemaV1 | undefined = undefined>(options: EngagementsOptions<S>): Engagements<FieldsOf<S>>;
+//#endregion
+export { EngagementsOptions as a, Engagements as i, EngagementInput as n, createEngagements as o, EngagementSubject as r, Engagement as t };

package/dist/entitlements-B_ttRvI6.js

@@ -0,0 +1,45 @@
+import { t as AsyncResult } from "./result-B3m7xtRY.js";
+import { j as run, o as blockCall } from "./block-helpers-CiKtrb6g.js";
+import { r as withBlockHooks } from "./block-hooks-BymdcD0V.js";
+//#region src/blocks/entitlements/entitlements.ts
+/** The Stripe event sent when a customer's active entitlements change. */
+const ENTITLEMENTS_UPDATED = "entitlements.active_entitlement_summary.updated";
+function stripeCustomerOf(payload) {
+	if (typeof payload !== "object" || payload === null) return;
+	const customer = (payload.data?.object)?.customer;
+	if (typeof customer === "string") return customer;
+	const id = customer?.id;
+	return typeof id === "string" ? id : void 0;
+}
+/**
+* Users whose `memberships` claim carries the entitlements of the Stripe
+* customer in an `entitlements.active_entitlement_summary.updated` event, so a
+* job can invalidate their sessions. Empty for other payloads.
+*/
+function entitlementMembers(sql, payload) {
+	const customer = stripeCustomerOf(payload);
+	if (customer === void 0) return AsyncResult.ok([]);
+	return run(() => sql.queryRaw("select user_id from better_supabase.entitlement_members($1) as user_id", [customer])).map((rows) => rows.map((row) => row.user_id));
+}
+/**
+* Reads the caller's entitlements through the `entitlements` module's
+* `has_entitlement` and `entitlement_value`, which check membership.
+*/
+function createEntitlements(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	return withBlockHooks({
+		has: (organizationId, key) => call("has_entitlement", {
+			tenant: organizationId,
+			key
+		}, (value) => value === true),
+		value: (organizationId, key) => call("entitlement_value", {
+			tenant: organizationId,
+			key
+		}, (value) => value === null ? void 0 : value)
+	}, options.hooks, {
+		block: "entitlements",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+export { createEntitlements as n, entitlementMembers as r, ENTITLEMENTS_UPDATED as t };

package/dist/entitlements-DDevu4ZE.d.ts

@@ -0,0 +1,54 @@
+import { t as AuthSnapshot } from "./bind-Dz8y3T5T.js";
+import { t as AuthSession } from "./view-2_I-2ukO.js";
+//#region src/auth/entitlements.d.ts
+/**
+ * One entry of the `memberships` claim when a hook writes it as a list. Hooks
+ * strip `null`s, so optional fields are absent rather than `null`.
+ */
+interface MembershipClaim {
+  /** The scope the membership is in, e.g. `tenant` or `organization`. */
+  readonly scope: string;
+  readonly id: string;
+  /** Parent scopes, e.g. `{ organization: '...' }` for a project membership. */
+  readonly within?: Readonly<Record<string, string>>;
+  readonly roles: readonly string[];
+  readonly via?: string;
+  /** Unix seconds. */
+  readonly expiresAt?: number;
+  readonly grantedBy?: string;
+  readonly reason?: string;
+  readonly member?: {
+    readonly group: string;
+  };
+  readonly managedBy?: "idp";
+  /** Seats, not plan features: those are in the `features` claim. */
+  readonly entitlements?: readonly string[];
+}
+/**
+ * Entitlement keys of the `features` claim: the literal union when
+ * `betterSupabase.claims(schema)` declares one (`z.enum([...])`), otherwise
+ * `string`.
+ */
+type EntitlementKey<C> = C extends {
+  readonly features?: infer F;
+} ? NonNullable<F> extends Readonly<Record<string, readonly (infer K)[]>> ? K extends string ? K : string : string : string;
+/** Where `hasEntitlement` reads the features claim, and its short codes. */
+interface EntitlementClaimOptions {
+  /** `config.claims.features`, default `features`. */
+  readonly claim?: string;
+  /** `entitlements.claim.keys`: the short code written for each feature key. */
+  readonly keys?: Readonly<Record<string, string>>;
+}
+/**
+ * Whether the session's plan-features claim grants `key` in `tenantId`. `claim`
+ * is `config.claims.features` (default `features`), the claim
+ * `better_supabase.feature_claims()` fills, or `{ claim, keys }` when
+ * `entitlements.claim.keys` writes short codes. The claim is as fresh as the
+ * token: enforce it in RLS with `better_supabase.has_entitlement()`, and
+ * refresh the session after checkout. A tenant left out by
+ * `entitlements.claim.maxTenants` reads as not granted. Takes a server session
+ * or the client's `useAuth()` snapshot.
+ */
+declare function hasEntitlement<C>(session: AuthSession<C> | AuthSnapshot, tenantId: string, key: EntitlementKey<C>, claim?: string | EntitlementClaimOptions): boolean;
+//#endregion
+export { hasEntitlement as i, EntitlementKey as n, MembershipClaim as r, EntitlementClaimOptions as t };

package/dist/entity-form-B67vq97h.d.ts

@@ -0,0 +1,82 @@
+import { rn as EntitySchema } from "./define-block-COpcS6aT.js";
+import { s as FormFieldType } from "./form-definition-BjEtH8BT.js";
+//#region src/records/entity-form.d.ts
+/** The input a field renders: a forms block field type, or a date and time. */
+type EntityFormInput = FormFieldType | "datetime";
+/** One field of an entity form, in render order. */
+interface EntityFormField {
+  /** The input key, or the custom field key. */
+  readonly key: string;
+  readonly label: string;
+  readonly input: EntityFormInput;
+  readonly required: boolean;
+  /** `entity` for the block's input, `custom` for the tenant's custom fields. */
+  readonly source: "entity" | "custom";
+  readonly description?: string;
+  /** The values an `option` or `multi` field offers. */
+  readonly options?: readonly string[];
+  readonly minimum?: number;
+  readonly maximum?: number;
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  /** A custom field marked sensitive. */
+  readonly sensitive?: boolean;
+}
+/** A custom field definition; `customFields.listDefinitions(entity)` fits. */
+interface EntityFormCustomField {
+  readonly key: string;
+  readonly label: string;
+  readonly type: string;
+  readonly required: boolean;
+  readonly sensitive?: boolean;
+}
+/** What a submitted form splits into: the block input and the custom values. */
+interface EntityFormValues<T> {
+  readonly input: T;
+  readonly custom: Readonly<Record<string, unknown>>;
+}
+type EntityFormResult<T> = ({
+  readonly ok: true;
+} & EntityFormValues<T>) | {
+  readonly ok: false;
+  /** One message per field key; `""` for an issue not on one field. */
+  readonly errors: Readonly<Record<string, string>>;
+};
+interface EntityForm<T> {
+  readonly fields: readonly EntityFormField[];
+  /** Checks the values with the entity schema and the custom fields' `required`. */
+  validate(values: Readonly<Record<string, unknown>>): Promise<EntityFormResult<T>>;
+}
+interface EntityFormOptions<T> {
+  /**
+   * The input keys to show, in order. Default: every key the schema accepts,
+   * except read-only ones.
+   */
+  readonly fields?: readonly (keyof T & string)[];
+  /** Labels by key. Default: the key in words (`dueAt` is `Due at`). */
+  readonly labels?: Readonly<Partial<Record<string, string>>>;
+  /** The tenant's custom fields for the entity, shown after the input fields. */
+  readonly customFields?: readonly EntityFormCustomField[];
+  /**
+   * The zone a `datetime-local` value is read in for an instant field. Default:
+   * `UTC`.
+   */
+  readonly timeZone?: string;
+}
+/**
+ * The fields of a form for one of a block's entities, from its input schema
+ * (`block.schemas.<entity>.input`) and the tenant's custom fields. `validate`
+ * runs the schema, so the form accepts what the block's `create` accepts.
+ *
+ * ```ts
+ * const form = entityForm(workItemsBlock.schemas.work_item.input, {
+ *   fields: ["title", "body", "priority", "dueAt"],
+ *   customFields: await customFields
+ *     .listDefinitions("work_item")
+ *     .orThrow(),
+ * });
+ * ```
+ */
+declare function entityForm<T>(schema: EntitySchema<T>, options?: EntityFormOptions<T>): EntityForm<T>;
+//#endregion
+export { EntityFormOptions as a, entityForm as c, EntityFormInput as i, EntityFormCustomField as n, EntityFormResult as o, EntityFormField as r, EntityFormValues as s, EntityForm as t };