better-supabase 0.5.0 → 0.6.0

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

@@ -0,0 +1,226 @@
+import { t as AsyncResult, w as ErrorMapper } from "../../result-D7y2fT87.js";
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-CKtbFcRv.js";
+//#region src/blocks/flags/flags.d.ts
+type FlagType = "boolean" | "string" | "number" | "object";
+type FlagValue = boolean | string | number | null | FlagValue[] | {
+  [key: string]: FlagValue;
+};
+/** A targeting rule: every list that is set must contain the caller's value. */
+interface FlagRule {
+  readonly variant: string;
+  readonly tenants?: readonly string[];
+  readonly users?: readonly string[];
+  /** Entitlement lookup keys; one match is enough. */
+  readonly plans?: readonly string[];
+  readonly roles?: readonly string[];
+}
+interface FlagOverride {
+  readonly organizationId: string | undefined;
+  readonly userId: string | undefined;
+  readonly variant: string;
+}
+/** A row of the `flags` table with its overrides (`flag_definitions()`). */
+interface FlagDefinition {
+  readonly key: string;
+  readonly type: FlagType;
+  readonly variants: Readonly<Record<string, FlagValue>>;
+  readonly defaultVariant: string;
+  readonly enabled: boolean;
+  readonly rules: readonly FlagRule[];
+  /** 0 to 100, in steps of 0.01. */
+  readonly rolloutPercentage: number;
+  readonly rolloutVariant: string | undefined;
+  readonly overrides: readonly FlagOverride[];
+}
+/**
+ * The OpenFeature evaluation context the provider reads. `targetingKey` is
+ * the user id; without one, the rollout buckets by `tenant`.
+ */
+interface FlagContext {
+  readonly targetingKey?: string;
+  readonly tenant?: string;
+  readonly plans?: readonly string[];
+  readonly role?: string;
+  /** Every role the caller holds in the tenant; a `roles` rule matches any of them. */
+  readonly roles?: readonly string[];
+  readonly [attribute: string]: unknown;
+}
+/**
+ * What `flagContext()` returns; an OpenFeature `EvaluationContext`. It is a
+ * type alias because an interface has no implicit index signature.
+ */
+type RequestFlagContext = {
+  targetingKey?: string;
+  tenant?: string;
+  plans?: string[];
+  role?: string;
+  roles?: string[];
+};
+type FlagReason = "DISABLED" | "TARGETING_MATCH" | "SPLIT" | "DEFAULT" | "ERROR";
+type FlagErrorCode = "FLAG_NOT_FOUND" | "TYPE_MISMATCH" | "PROVIDER_NOT_READY" | "GENERAL";
+/**
+ * The shape of an OpenFeature `ResolutionDetails`. `Code` is the type of
+ * `errorCode`: OpenFeature's `ErrorCode` when `errorCodes: ErrorCode` is
+ * passed to the provider, the matching string literals otherwise.
+ */
+interface FlagResolution<T, Code extends string = FlagErrorCode> {
+  readonly value: T;
+  readonly variant?: string;
+  readonly reason: FlagReason;
+  readonly errorCode?: Code;
+  readonly errorMessage?: string;
+}
+/** The shape of an OpenFeature `EvaluationDetails`. */
+interface FlagDetails<T, Code extends string = FlagErrorCode> extends FlagResolution<T, Code> {
+  readonly flagKey: string;
+  readonly flagMetadata: Readonly<Record<string, string | number | boolean>>;
+}
+/**
+ * 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.
+ */
+export declare function flagBucket(flag: string, target: string): Promise<number>;
+/** The result of `evaluateFlag()`, which never fails. */
+interface FlagEvaluation {
+  readonly value: FlagValue;
+  readonly variant: string;
+  readonly reason: FlagReason;
+}
+/** Evaluates one flag as `better_supabase.flag_evaluation()` does. */
+export declare function evaluateFlag(flag: FlagDefinition, context?: FlagContext): Promise<FlagEvaluation>;
+/** Parses the rows of `flag_definitions()`. */
+export declare function flagDefinitionsOf(value: unknown): readonly FlagDefinition[];
+interface FlagsProviderOptions<Code extends string = FlagErrorCode> extends BlockTemporalOptions {
+  /**
+   * A service-role transport: `flag_definitions()` is granted to
+   * `service_role` only, as it lists every override.
+   */
+  readonly transport?: BlockTransport;
+  /** The module schema (`sql.modules.flags.schema`), default `better_supabase`. */
+  readonly schema?: string;
+  /** How long the definitions are cached, in milliseconds. Default 30000. */
+  readonly ttl?: number;
+  /** Fixed definitions instead of a transport, for tests and static flags. */
+  readonly definitions?: readonly FlagDefinition[];
+  /**
+   * OpenFeature's `ErrorCode` enum (from `@openfeature/core` or
+   * `@openfeature/server-sdk`), so the provider's types match `Provider`.
+   */
+  readonly errorCodes?: Readonly<Record<FlagErrorCode, Code>>;
+  readonly now?: () => number;
+}
+/**
+ * The shape of an OpenFeature server `Provider`. Pass it to
+ * `OpenFeature.setProviderAndWait()`; this package never imports OpenFeature.
+ */
+interface FlagsProvider<Code extends string = FlagErrorCode> {
+  readonly metadata: {
+    readonly name: string;
+  };
+  readonly runsOn: "server";
+  initialize(context?: FlagContext): Promise<void>;
+  resolveBooleanEvaluation(flagKey: string, defaultValue: boolean, context: FlagContext): Promise<FlagResolution<boolean, Code>>;
+  resolveStringEvaluation(flagKey: string, defaultValue: string, context: FlagContext): Promise<FlagResolution<string, Code>>;
+  resolveNumberEvaluation(flagKey: string, defaultValue: number, context: FlagContext): Promise<FlagResolution<number, Code>>;
+  resolveObjectEvaluation<T extends FlagValue>(flagKey: string, defaultValue: T, context: FlagContext): Promise<FlagResolution<T, Code>>;
+  /** Drops the cache, so the next evaluation reloads the definitions. */
+  refresh(): void;
+}
+/** Feature flags from the `flags` module, as an OpenFeature provider. */
+export declare function createFlagsProvider<Code extends string = FlagErrorCode>(options: FlagsProviderOptions<Code>): FlagsProvider<Code>;
+/**
+ * The four `get*Details` methods that the OpenFeature server `Client` and
+ * the `FlagClient` of `@supabase-labs/middleware-openfeature` share.
+ */
+interface FlagClient<Code extends string = FlagErrorCode> {
+  getBooleanDetails(flagKey: string, defaultValue: boolean, context?: FlagContext): Promise<FlagDetails<boolean, Code>>;
+  getStringDetails(flagKey: string, defaultValue: string, context?: FlagContext): Promise<FlagDetails<string, Code>>;
+  getNumberDetails(flagKey: string, defaultValue: number, context?: FlagContext): Promise<FlagDetails<number, Code>>;
+  getObjectDetails<T extends FlagValue>(flagKey: string, defaultValue: T, context?: FlagContext): Promise<FlagDetails<T, Code>>;
+}
+/**
+ * A flag client without the OpenFeature SDK: `withOpenFeature({ client })`
+ * from `@supabase-labs/middleware-openfeature` accepts it.
+ */
+export declare function createFlagClient<Code extends string = FlagErrorCode>(source: FlagsProvider<Code> | FlagsProviderOptions<Code>): FlagClient<Code>;
+interface FlagContextSource {
+  /** `ctx.jwtClaims` from `withBetterSupabase`, or verified claims. */
+  readonly jwtClaims?: Readonly<Record<string, unknown>> | null | undefined;
+  /** The active tenant; default the `tenant_id` claim. */
+  readonly tenant?: string | null | undefined;
+}
+interface FlagContextOptions {
+  /** `config.claims.tenant`, default `tenant_id`. */
+  readonly tenantClaim?: string;
+  /** `config.claims.features`, default `features`. */
+  readonly featuresClaim?: string;
+  /** The claim the memberships hook writes, default `memberships`. */
+  readonly membershipsClaim?: string;
+  /**
+   * The scope of tenant memberships when the claim is a list of entries, as
+   * an authorization provider's hook may write it (`{ scope, id, roles }`). Without it, the entry
+   * for the tenant id that has no `within` (a root scope) is read.
+   */
+  readonly membershipScope?: string;
+  /** Reads the caller's roles in `tenant` from claims of another shape. */
+  readonly roles?: (claims: Readonly<Record<string, unknown>>, tenant: string) => string | readonly string[] | undefined;
+}
+/**
+ * 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`.
+ */
+export declare function flagContext(source: FlagContextSource, options?: FlagContextOptions): RequestFlagContext;
+//#endregion
+//#region src/blocks/flags/admin.d.ts
+interface FlagAdminOptions {
+  /**
+   * The caller's transport: `rpcTransport(supabase, { schema: "api" })` for
+   * platform staff over the Data API, or a service-role transport.
+   */
+  readonly transport: BlockTransport;
+  /** The module schema (`sql.modules.flags.schema`), default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** The fields `save` writes; the ones left out keep their value. */
+interface FlagInput {
+  readonly type?: FlagType;
+  readonly description?: string | null;
+  readonly variants?: Readonly<Record<string, FlagValue>>;
+  readonly defaultVariant?: string;
+  readonly enabled?: boolean;
+  readonly rules?: readonly FlagRule[];
+  /** 0 to 100. */
+  readonly rolloutPercentage?: number;
+  readonly rolloutVariant?: string | null;
+}
+/** The override target: one tenant or one user. */
+type FlagOverrideTarget = {
+  readonly organizationId: string;
+  readonly userId?: never;
+} | {
+  readonly userId: string;
+  readonly organizationId?: never;
+};
+interface FlagAdmin {
+  /** Every flag with its overrides. */
+  list(): AsyncResult<readonly FlagDefinition[]>;
+  /** Creates or updates a flag; returns it as stored. */
+  save(key: string, input: FlagInput): AsyncResult<FlagDefinition | undefined>;
+  /** `false` when there was no such flag. */
+  remove(key: string): AsyncResult<boolean>;
+  /** Sets a tenant's or a user's variant; `null` removes the override. */
+  override(key: string, target: FlagOverrideTarget, variant: string | null): AsyncResult<boolean>;
+}
+/**
+ * Manages feature flags for platform staff (`flags.manage`) or the service
+ * role, through the `flags` module's `list_flags`, `save_flag`,
+ * `delete_flag` and `set_flag_override`.
+ */
+export declare function createFlagAdmin(options: FlagAdminOptions): FlagAdmin;
+//#endregion
+export { type BlockTransport, type FlagAdmin, type FlagAdminOptions, type FlagClient, type FlagContext, type FlagContextOptions, type FlagContextSource, type FlagDefinition, type FlagDetails, type FlagErrorCode, type FlagEvaluation, type FlagInput, type FlagOverride, type FlagOverrideTarget, type FlagReason, type FlagResolution, type FlagRule, type FlagType, type FlagValue, type FlagsProvider, type FlagsProviderOptions, type RequestFlagContext, rpcTransport, sqlTransport };

package/dist/blocks/flags/index.js

@@ -0,0 +1,282 @@
+import { t as DEFAULT_CLAIMS } from "../../claims-PqzCxaTD.js";
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { D as stringsOf, O as textOf, c as errorText, d as isRecord, h as optionalText, i as blockCall, n as applyTemporal, x as recordsOf } from "../../block-helpers-DWHxHsEQ.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));
+}
+async function chooseVariant(flag, context) {
+	if (!flag.enabled) 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))?.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);
+	return {
+		value: flag.variants[variant] ?? null,
+		variant,
+		reason
+	};
+}
+const FLAG_TYPES = /* @__PURE__ */ new Set([
+	"boolean",
+	"string",
+	"number",
+	"object"
+]);
+const flagTypeOf = (value) => {
+	const text = textOf(value);
+	return FLAG_TYPES.has(text) ? text : "boolean";
+};
+function ruleOf(value) {
+	if (!isRecord(value) || typeof value["variant"] !== "string") return void 0;
+	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");
+	return {
+		variant: value["variant"],
+		...tenants && { tenants },
+		...users && { users },
+		...plans && { plans },
+		...roles && { roles }
+	};
+}
+/** Parses the rows of `flag_definitions()`. */
+function flagDefinitionsOf(value) {
+	return recordsOf(value, "flag_definitions").map((row) => ({
+		key: textOf(row["key"]),
+		type: flagTypeOf(row["type"]),
+		variants: isRecord(row["variants"]) ? row["variants"] : {},
+		defaultVariant: optionalText(row["default_variant"]) ?? "",
+		enabled: row["enabled"] !== false,
+		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((entry) => ({
+			organizationId: optionalText(entry["organization_id"]),
+			userId: optionalText(entry["user_id"]),
+			variant: textOf(entry["variant"])
+		}))
+	}));
+}
+const DEFAULT_CODES = {
+	FLAG_NOT_FOUND: "FLAG_NOT_FOUND",
+	TYPE_MISMATCH: "TYPE_MISMATCH",
+	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 schema = options.schema ?? "better_supabase";
+	const fetchFlags = definitions ? () => Promise.resolve(definitions) : transport ? async () => flagDefinitionsOf(await transport.call(schema, "flag_definitions", {})) : 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`
+		};
+		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),
+		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];
+	return {
+		...sub !== void 0 && { targetingKey: sub },
+		...tenant !== void 0 && { tenant },
+		...plans !== void 0 && { plans },
+		...roles.length > 0 && { role: roles[0] },
+		...roles.length > 1 && { roles }
+	};
+}
+//#endregion
+//#region src/blocks/flags/admin.ts
+const rowOf = (input) => {
+	const row = {};
+	const set = (name, value) => {
+		if (value !== void 0) row[name] = value;
+	};
+	set("type", input.type);
+	set("description", input.description);
+	set("variants", input.variants);
+	set("default_variant", input.defaultVariant);
+	set("enabled", input.enabled);
+	set("rules", input.rules);
+	set("rollout_percentage", input.rolloutPercentage);
+	set("rollout_variant", input.rolloutVariant);
+	return row;
+};
+/**
+* Manages feature flags for platform staff (`flags.manage`) or the service
+* role, through the `flags` module's `list_flags`, `save_flag`,
+* `delete_flag` and `set_flag_override`.
+*/
+function createFlagAdmin(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	return {
+		list: () => call("list_flags", {}, flagDefinitionsOf),
+		save: (key, input) => call("save_flag", {
+			key,
+			definition: rowOf(input)
+		}, (value) => flagDefinitionsOf(value === null ? [] : [value])[0]),
+		remove: (key) => call("delete_flag", { key }, (value) => value === true),
+		override: (key, target, variant) => call("set_flag_override", {
+			key,
+			variant,
+			tenant: target.organizationId,
+			member: target.userId
+		}, (value) => value === true)
+	};
+}
+//#endregion
+export { createFlagAdmin, createFlagClient, createFlagsProvider, evaluateFlag, flagBucket, flagContext, flagDefinitionsOf, rpcTransport, sqlTransport };

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

@@ -0,0 +1,6 @@
+import { i as sqlTransport, n as RpcClient, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { A as PurgedContact, C as InboxMessage, D as MessageDirection, E as MessageDelivery, O as MessageKind, S as InboxCounts, T as MessageAttachment, _ as ConversationPriority, a as Inbox, b as InboundResult, c as MessageInput, d as createInbox, f as AuthorType, g as ConversationEvent, h as Conversation, i as InboundInput, j as StoredInboundEvent, k as MessageTemplate, l as StartConversationInput, m as Contact, n as ConversationFilter, o as InboxOptions, p as BotMode, r as CreateInboxInput, s as InboxPatch, t as ContactInput, u as TemplateInput, v as ConversationStatus, w as InboxRow, x as InboxChannel, y as DeliveryStatus } from "../../inbox-i7E1ppo6.js";
+//#region src/blocks/inbox/rows.d.ts
+export declare const INBOX_CHANNELS: readonly InboxChannel[];
+//#endregion
+export { type AuthorType, type BlockTransport, type BotMode, type Contact, type ContactInput, type Conversation, type ConversationEvent, type ConversationFilter, type ConversationPriority, type ConversationStatus, type CreateInboxInput, type DeliveryStatus, type InboundInput, type InboundResult, type Inbox, type InboxChannel, type InboxCounts, type InboxMessage, type InboxOptions, type InboxPatch, type InboxRow, type MessageAttachment, type MessageDelivery, type MessageDirection, type MessageInput, type MessageKind, type MessageTemplate, type PurgedContact, type RpcClient, type StartConversationInput, type StoredInboundEvent, type TemplateInput, createInbox, rpcTransport, sqlTransport };