better-supabase 0.12.0 → 0.14.0

package/dist/client-DzukpHS1.d.ts

@@ -0,0 +1,165 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-C6jDfedy.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-BaugZlJV.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+import { i as KeyboardPort } from "./ports-DsJicwI2.js";
+import { n as Controller } from "./controller-DAD4hbl4.js";
+//#region src/blocks/search/search.d.ts
+interface SearchOptions extends Pick<BlockOptions, "transport" | "service" | "schema" | "mappers"> {
+  /** `withBlockHooks` hooks around the methods. */
+  readonly hooks?: BlockHooks<Search>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** One match, with the title and URL from `config.subjects`. */
+interface SearchHit {
+  readonly organizationId: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  /** A fragment of the body around the match, without markup. */
+  readonly snippet: string | null;
+  readonly score: number;
+}
+interface SearchQuery {
+  /** Subject types to search. Default: every type with a `search` entry. */
+  readonly types?: readonly string[];
+  /** One tenant. Default: every tenant the caller can read. */
+  readonly organizationId?: string | null;
+  /** At most 100. Default 20. */
+  readonly limit?: number;
+  /**
+   * The query's embedding, when the index keeps embeddings
+   * (`blocks.search.options.dimensions` and `vector-search`): the results fuse
+   * full-text and nearest-neighbour ranks.
+   */
+  readonly embedding?: readonly number[] | null;
+}
+/** A subject the caller opened or starred (the share-links per-user state). */
+interface SearchUserItem {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  readonly openedAt: Temporal.Instant | undefined;
+  readonly starredAt: Temporal.Instant | undefined;
+}
+interface SearchListOptions {
+  /** At most 100. Default 10. */
+  readonly limit?: number;
+  readonly types?: readonly string[];
+}
+/** A document whose text has no embedding yet. */
+interface PendingEmbedding {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** Pass it back to `setEmbedding`, which skips text that changed since. */
+  readonly contentHash: string;
+  /** The title and body to embed. */
+  readonly text: string;
+}
+/** Embeds texts in order, one vector per text: an AI SDK `embedMany` call. */
+type Embedder = (texts: readonly string[]) => Promise<readonly (readonly number[])[]>;
+interface Search {
+  /**
+   * Searches as the caller: `websearch_to_tsquery` syntax (`"exact phrase"`,
+   * `-word`, `or`), prefixes for typeahead and trigram matches for typos. Rows
+   * the caller can't read, and trashed rows, are left out.
+   */
+  search(q: string, query?: SearchQuery): AsyncResult<readonly SearchHit[]>;
+  /** The caller's recently opened subjects, newest first. */
+  recents(options?: SearchListOptions): AsyncResult<readonly SearchUserItem[]>;
+  /** The caller's starred subjects, newest first. */
+  favorites(options?: SearchListOptions): AsyncResult<readonly SearchUserItem[]>;
+  /** Records that the caller opened a subject, for `recents`. */
+  touch(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Stars or unstars a subject for the caller, for `favorites`. */
+  star(subjectType: string, subjectId: string, starred?: boolean): AsyncResult<boolean>;
+  /** Reads one row into the index again. Service only. */
+  refresh(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Drops one subject from the index. Service only. */
+  remove(subjectType: string, subjectId: string): AsyncResult<boolean>;
+  /** Indexes every row of one type, or of all of them. Service only. */
+  reindex(subjectType?: string): AsyncResult<number>;
+  /** Documents without an embedding, oldest first. Service only. */
+  pendingEmbeddings(limit?: number): AsyncResult<readonly PendingEmbedding[]>;
+  /** Stores an embedding unless the text changed. Service only. */
+  setEmbedding(document: Pick<PendingEmbedding, "subjectType" | "subjectId" | "contentHash">, embedding: readonly number[]): AsyncResult<boolean>;
+  /**
+   * Embeds up to `limit` pending documents with `embed` and stores them. Run it
+   * from a job or cron. Service only. Resolves to the number stored.
+   */
+  embedPending(embed: Embedder, limit?: number): AsyncResult<number>;
+}
+/**
+ * The `search` SQL module as typed calls. Build it with the caller's transport
+ * for `search`, `recents` and `favorites`, and pass `service` for the index
+ * maintenance methods.
+ */
+declare function createSearch(options: SearchOptions): Search;
+//#endregion
+//#region src/blocks/search/groups.d.ts
+/** A row of the dialog: a match, a recent or a favorite. */
+interface CommandSearchItem {
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly title: string | null;
+  readonly url: string | null;
+  readonly snippet?: string | null;
+}
+/** One heading of the dialog: `favorites`, `recents`, or a subject type. */
+interface CommandSearchGroup {
+  readonly key: string;
+  readonly items: readonly CommandSearchItem[];
+}
+/** Groups matches by subject type, in the order the best match of each appears. */
+declare function groupHits(hits: readonly SearchHit[]): readonly CommandSearchGroup[];
+//#endregion
+//#region src/blocks/search/client.d.ts
+interface CommandSearchOptions {
+  readonly client: Pick<Search, "search" | "recents" | "favorites" | "touch" | "star">;
+  /** Toggles the dialog on Cmd+K and Ctrl+K. Without it there is no shortcut. */
+  readonly keyboard?: KeyboardPort;
+  /** One tenant. Default: every tenant the caller can read. */
+  readonly organizationId?: string | null;
+  readonly types?: readonly string[];
+  /** Results per query. Default 20. */
+  readonly limit?: number;
+  /** Recents and favorites shown before the user types. Default 5. */
+  readonly listLimit?: number;
+  /** Milliseconds between the last keystroke and the query. Default 150. */
+  readonly debounceMs?: number;
+}
+interface CommandSearchSnapshot {
+  readonly open: boolean;
+  readonly query: string;
+  /**
+   * Favorites and recents for an empty query, otherwise the matches by subject
+   * type.
+   */
+  readonly groups: readonly CommandSearchGroup[];
+  readonly results: readonly SearchHit[];
+  readonly recents: readonly SearchUserItem[];
+  readonly favorites: readonly SearchUserItem[];
+  /** True while a query newer than `results` is running. */
+  readonly loading: boolean;
+  readonly error: DbError | undefined;
+}
+interface CommandSearchActions {
+  readonly setOpen: (open: boolean) => void;
+  readonly setQuery: (query: string) => void;
+  /** Records the item as opened (for recents) and closes the dialog. */
+  readonly select: (item: CommandSearchItem) => Promise<void>;
+  readonly star: (item: CommandSearchItem, starred?: boolean) => Promise<void>;
+}
+type CommandSearchController = Controller<CommandSearchSnapshot, CommandSearchActions>;
+/**
+ * State for a Cmd+K dialog over the `search` module: a debounced query that
+ * ignores stale responses, favorites and recents for an empty query, and
+ * `select` that records the open.
+ */
+declare function createCommandSearchController(options: CommandSearchOptions): CommandSearchController;
+//#endregion
+export { createSearch as _, createCommandSearchController as a, groupHits as c, Search as d, SearchHit as f, SearchUserItem as g, SearchQuery as h, CommandSearchSnapshot as i, Embedder as l, SearchOptions as m, CommandSearchController as n, CommandSearchGroup as o, SearchListOptions as p, CommandSearchOptions as r, CommandSearchItem as s, CommandSearchActions as t, PendingEmbedding as u };

package/dist/client-LngH55pZ.d.ts

@@ -0,0 +1,83 @@
+import { b as DbError, t as AsyncResult } from "./result-C6jDfedy.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions, o as BlockTenant } from "./block-helpers-BaugZlJV.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+import { B as PermissionFlags, V as PermissionSet } from "./index-DbXWcrOI.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/access/access.d.ts
+interface AccessOptions extends BlockOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Access>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** Which tenant one call checks in, instead of the block's `tenant`. */
+interface AccessCallOptions {
+  readonly tenant?: BlockTenant;
+}
+/**
+ * The caller's permissions in the block's tenant, through the access contract:
+ * the roles or catalog model, the app's own functions, or the
+ * `AuthorizationProvider`. `K` types the keys; annotate the client as
+ * `Access<PermissionKey>` with the key union `gen` writes.
+ */
+interface Access<K extends string = string> {
+  /**
+   * The keys of `keys` the caller holds, checked one by one with `can()`.
+   * Without `keys`, every key the access model lists for the caller, wildcards
+   * included; the `custom` model lists none, so pass the keys you check.
+   */
+  permissions(keys?: readonly K[], options?: AccessCallOptions): AsyncResult<PermissionSet>;
+  /** Whether the caller holds `key`. */
+  can(key: K, options?: AccessCallOptions): AsyncResult<boolean>;
+  /**
+   * One `can<Name>` boolean per entry of `flags`, in one call: `{ edit:
+   * "customers.write" }` resolves to `{ canEdit: true }`.
+   */
+  flags<const M extends Readonly<Record<string, K>>>(flags: M, options?: AccessCallOptions): AsyncResult<PermissionFlags<M>>;
+}
+/**
+ * The `access` module's `my_permissions` as typed calls. It acts in the block's
+ * `tenant`; `createBlocks` and `createBlockClient` pass the request's.
+ */
+declare function createAccess<K extends string = string>(options: AccessOptions): Access<K>;
+//#endregion
+//#region src/blocks/access/client.d.ts
+/** What the permissions controller reads: `createAccess()` or a batch of it. */
+type PermissionSource<K extends string = string> = Pick<Access<K>, "permissions">;
+/**
+ * Joins the `permissions(keys)` calls made in the same tick for one tenant into
+ * one `my_permissions` call, so every `<Can>` on a screen costs one round trip.
+ * Each caller gets back only the keys it asked for.
+ */
+declare function batchPermissions<K extends string>(source: PermissionSource<K>): PermissionSource<K>;
+interface PermissionsControllerOptions<K extends string = string> {
+  /** `createAccess()`, ideally through `batchPermissions`. */
+  readonly client: PermissionSource<K>;
+  readonly auth: AuthPort;
+  /** The keys to check. */
+  readonly keys: readonly K[];
+  /**
+   * The organization to check in. Without one every key reads false and nothing
+   * loads.
+   */
+  readonly tenant: string | undefined;
+}
+interface PermissionsSnapshot {
+  /** `undefined` until the first load, and while signed out or without a tenant. */
+  readonly permissions: PermissionSet | undefined;
+  readonly error: DbError | undefined;
+}
+interface PermissionsActions {
+  /** Checks the keys again, such as after a role change the session missed. */
+  readonly refresh: () => Promise<void>;
+}
+type PermissionsController = Controller<PermissionsSnapshot, PermissionsActions>;
+/**
+ * Which of `keys` the caller holds in `tenant`, for showing or hiding UI. It
+ * loads again when another user signs in. UX only: RLS and the SQL functions
+ * check every key again.
+ */
+declare function createPermissionsController<K extends string>(options: PermissionsControllerOptions<K>): PermissionsController;
+//#endregion
+export { PermissionsSnapshot as a, Access as c, createAccess as d, PermissionsControllerOptions as i, AccessCallOptions as l, PermissionsActions as n, batchPermissions as o, PermissionsController as r, createPermissionsController as s, PermissionSource as t, AccessOptions as u };

package/dist/client-PPSwiJaK.js

@@ -0,0 +1,291 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { r as err, s as toDbError } from "./result-B3m7xtRY.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { t as tenantOf } from "./tenant-DnMqeNIM.js";
+//#region src/blocks/organizations/client.ts
+/**
+* The caller's organizations and the active one, for an organization switcher:
+* `switchTo` switches, refreshes the session through `onSwitched` and loads the
+* list again.
+*/
+function createOrganizationsController(options) {
+	let chosen = options.activeId ?? void 0;
+	const activeOf = () => {
+		const session = options.auth.current();
+		return (session.status === "signed-in" ? tenantOf(session, options.claim) : void 0) ?? chosen;
+	};
+	return defineController({
+		organizations: options.initial,
+		activeId: activeOf(),
+		switching: void 0,
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		let seeded = options.initial !== void 0;
+		const refresh = async () => {
+			ticket += 1;
+			const request = ticket;
+			try {
+				const organizations = await options.load();
+				if (request === ticket) state.set({
+					organizations,
+					error: void 0
+				});
+			} catch (cause) {
+				if (request === ticket) state.set({ error: toDbError(cause) });
+			}
+		};
+		return {
+			actions: {
+				refresh,
+				switchTo: async (organizationId) => {
+					state.set({
+						switching: organizationId,
+						error: void 0
+					});
+					const result = await options.client.switch(organizationId);
+					if (!result.ok) {
+						state.set({
+							switching: void 0,
+							error: result.error
+						});
+						return result;
+					}
+					try {
+						await options.onSwitched(result.data);
+					} catch (cause) {
+						const error = toDbError(cause);
+						state.set({
+							switching: void 0,
+							error
+						});
+						return err(error);
+					}
+					chosen = result.data.organizationId;
+					state.set({
+						switching: void 0,
+						activeId: activeOf()
+					});
+					await refresh();
+					return result;
+				}
+			},
+			start: () => {
+				const unsubscribe = options.auth.subscribe(() => {
+					state.set({ activeId: activeOf() });
+				});
+				state.set({ activeId: activeOf() });
+				const stop = whileSignedIn(options.auth, () => {
+					if (seeded) seeded = false;
+					else refresh();
+				});
+				return () => {
+					unsubscribe();
+					stop();
+				};
+			}
+		};
+	});
+}
+const without = (list, id) => list.filter((each) => each !== id);
+const noOrganization = () => err(dbError("invalid_input", "No organization is active"));
+/**
+* One organization's members for a members table: `setRole` changes a role
+* optimistically, `remove` removes a member, and both run `onChanged` once the
+* database committed.
+*/
+function createMembersController(options) {
+	const { client, organizationId } = options;
+	return defineController({
+		members: options.initial,
+		pending: [],
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		let seeded = options.initial !== void 0;
+		const refresh = async () => {
+			if (organizationId === null) return;
+			ticket += 1;
+			const request = ticket;
+			try {
+				const members = await options.load(organizationId);
+				if (request === ticket) state.set({
+					members,
+					error: void 0
+				});
+			} catch (cause) {
+				if (request === ticket) state.set({ error: toDbError(cause) });
+			}
+		};
+		const changed = async (change) => {
+			try {
+				await options.onChanged?.(change);
+			} catch (cause) {
+				state.set({ error: toDbError(cause) });
+			}
+		};
+		const withRole = (userId, role) => (current) => ({ members: current.members?.map((member) => member.userId === userId ? {
+			...member,
+			role
+		} : member) });
+		return {
+			actions: {
+				refresh,
+				setRole: async (userId, role) => {
+					if (organizationId === null) return noOrganization();
+					const before = state.get().members?.find((member) => member.userId === userId);
+					ticket += 1;
+					state.set((current) => ({
+						...withRole(userId, role)(current),
+						pending: [...current.pending, userId],
+						error: void 0
+					}));
+					const result = await client.updateMemberRole(organizationId, userId, role);
+					state.set((current) => ({
+						...result.ok || before === void 0 ? {} : withRole(userId, before.role)(current),
+						pending: without(current.pending, userId),
+						...result.ok ? {} : { error: result.error }
+					}));
+					if (result.ok) await changed({
+						kind: "role",
+						organizationId,
+						userId,
+						role
+					});
+					return result;
+				},
+				remove: async (userId) => {
+					if (organizationId === null) return noOrganization();
+					state.set((current) => ({
+						pending: [...current.pending, userId],
+						error: void 0
+					}));
+					const result = await client.removeMember(organizationId, userId);
+					ticket += 1;
+					state.set((current) => ({
+						pending: without(current.pending, userId),
+						...result.ok ? { members: current.members?.filter((member) => member.userId !== userId) } : { error: result.error }
+					}));
+					if (result.ok) {
+						await refresh();
+						await changed({
+							kind: "removed",
+							organizationId,
+							userId
+						});
+					}
+					return result;
+				}
+			},
+			start: () => organizationId === null ? void 0 : whileSignedIn(options.auth, () => {
+				if (seeded) seeded = false;
+				else refresh();
+			})
+		};
+	});
+}
+/**
+* One organization's open invitations for an invite dialog: `invite` sends one
+* and keeps its token in `sent` for the accept link, `revoke` revokes one, and
+* both load the list again.
+*/
+function createInvitationsController(options) {
+	const { client, organizationId } = options;
+	return defineController({
+		invitations: options.initial,
+		inviting: false,
+		sent: void 0,
+		revoking: [],
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		let seeded = options.initial !== void 0;
+		const refresh = async () => {
+			if (organizationId === null) return;
+			ticket += 1;
+			const request = ticket;
+			try {
+				const invitations = await options.load(organizationId);
+				if (request === ticket) state.set({
+					invitations,
+					error: void 0
+				});
+			} catch (cause) {
+				if (request === ticket) state.set({ error: toDbError(cause) });
+			}
+		};
+		const changed = async (change) => {
+			try {
+				await options.onChanged?.(change);
+			} catch (cause) {
+				state.set({ error: toDbError(cause) });
+			}
+		};
+		return {
+			actions: {
+				refresh,
+				clear: () => {
+					state.set({
+						sent: void 0,
+						error: void 0
+					});
+				},
+				invite: async (draft) => {
+					if (organizationId === null) return noOrganization();
+					state.set({
+						inviting: true,
+						sent: void 0,
+						error: void 0
+					});
+					const result = await client.invite({
+						...draft,
+						organizationId
+					});
+					state.set(result.ok ? {
+						inviting: false,
+						sent: result.data
+					} : {
+						inviting: false,
+						error: result.error
+					});
+					if (result.ok) {
+						await refresh();
+						await changed({
+							kind: "invited",
+							organizationId,
+							sent: result.data
+						});
+					}
+					return result;
+				},
+				revoke: async (invitationId) => {
+					if (organizationId === null) return noOrganization();
+					state.set((current) => ({
+						revoking: [...current.revoking, invitationId],
+						error: void 0
+					}));
+					const result = await client.revokeInvitation(invitationId);
+					state.set((current) => ({
+						revoking: without(current.revoking, invitationId),
+						...result.ok ? {} : { error: result.error }
+					}));
+					if (result.ok) {
+						await refresh();
+						await changed({
+							kind: "revoked",
+							organizationId,
+							invitationId
+						});
+					}
+					return result;
+				}
+			},
+			start: () => organizationId === null ? void 0 : whileSignedIn(options.auth, () => {
+				if (seeded) seeded = false;
+				else refresh();
+			})
+		};
+	});
+}
+//#endregion
+export { createMembersController as n, createOrganizationsController as r, createInvitationsController as t };

package/dist/client-RoAuPQNB.d.ts

@@ -0,0 +1,103 @@
+import { b as DbError, f as Result } from "./result-C6jDfedy.js";
+import { g as NewMessage, i as ConversationSummary, l as MessageEdition, m as Messaging, o as Message, r as ConversationKind } from "./messaging-CZ6aWb10.js";
+import { p as SubscriptionStatus } from "./topic-D9j8G2dw.js";
+import { n as TopicPort } from "./watch-topic-CIT3UlAh.js";
+import { n as Controller, t as AuthPort } from "./controller-DAD4hbl4.js";
+//#region src/blocks/messaging/client.d.ts
+interface MessagesControllerOptions {
+  readonly client: Pick<Messaging, "list" | "replies" | "get" | "send" | "edit" | "remove" | "pin" | "resolve" | "markRead">;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The conversation (or channel) to follow; the view waits without one. */
+  readonly conversationId: string | null;
+  /**
+   * A thread's root message: the view shows its replies instead of the
+   * conversation's top-level messages.
+   */
+  readonly threadId?: string | null;
+  /** `blocks.messaging.options.topic`, default `messages`. */
+  readonly topic?: string;
+  /** Messages per page, default 50. */
+  readonly limit?: number;
+  /**
+   * Moves the caller's read marker on load and on each new message; default
+   * true.
+   */
+  readonly markRead?: boolean;
+  /** How long a typing indicator lasts without a new broadcast, default 6000 ms. */
+  readonly typingTimeout?: number;
+}
+interface MessagesSnapshot {
+  /** Oldest first; `undefined` until the first load. */
+  readonly messages: readonly Message[] | undefined;
+  /** Whether `loadOlder` may find more. */
+  readonly hasOlder: boolean;
+  /** The other people typing now, by user id. */
+  readonly typing: readonly string[];
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+/** A reply, a rich-text document, mentions or files for `send`. */
+type MessageDraft = Omit<NewMessage, "body">;
+interface MessagesActions {
+  /**
+   * Sends a message, or a reply in the thread view; a failure is also kept in
+   * `error`.
+   */
+  readonly send: (body: string, draft?: MessageDraft) => Promise<Result<Message>>;
+  readonly edit: (id: string, edition: MessageEdition) => Promise<Result<Message>>;
+  /** Deletes a message; it stays as a placeholder. */
+  readonly remove: (id: string) => Promise<Result<boolean>>;
+  readonly pin: (id: string, pinned?: boolean) => Promise<Result<Message>>;
+  readonly resolve: (id: string, resolved?: boolean) => Promise<Result<Message>>;
+  /** Loads the page before the oldest message shown. */
+  readonly loadOlder: () => Promise<void>;
+  /** Tells the others the caller is typing, or stopped. */
+  readonly setTyping: (typing: boolean) => void;
+  readonly markRead: () => Promise<void>;
+  readonly refresh: () => Promise<void>;
+}
+type MessagesController = Controller<MessagesSnapshot, MessagesActions>;
+/**
+ * One conversation, or one thread, for the signed-in user: loads the latest
+ * page, keeps it current from the conversation's Realtime pings, tracks who is
+ * typing, and moves the read marker as messages arrive.
+ */
+declare function createMessagesController(options: MessagesControllerOptions): MessagesController;
+interface ConversationsControllerOptions {
+  readonly client: Pick<Messaging, "conversations">;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** Whether the caller acts in a tenant; the list waits without one. */
+  readonly enabled: boolean;
+  /** Only these kinds, such as `["channel"]`. */
+  readonly kinds?: readonly ConversationKind[];
+  readonly limit?: number;
+  readonly topic?: string;
+  /**
+   * How many of the listed conversations to follow on Realtime for new
+   * messages, default 50. Unread counts of the others change on `refresh`.
+   */
+  readonly watch?: number;
+}
+interface ConversationsSnapshot {
+  /** Latest message first, with unread counts; `undefined` until loaded. */
+  readonly conversations: readonly ConversationSummary[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface ConversationsActions {
+  readonly refresh: () => Promise<void>;
+}
+type ConversationsController = Controller<ConversationsSnapshot, ConversationsActions>;
+/**
+ * The caller's conversations with their unread and mention counts, loaded again
+ * when a message arrives in one of them.
+ */
+declare function createConversationsController(options: ConversationsControllerOptions): ConversationsController;
+//#endregion
+export { MessageDraft as a, MessagesControllerOptions as c, createMessagesController as d, ConversationsSnapshot as i, MessagesSnapshot as l, ConversationsController as n, MessagesActions as o, ConversationsControllerOptions as r, MessagesController as s, ConversationsActions as t, createConversationsController as u };