better-supabase 0.8.0 → 0.10.0

package/dist/client-BpS8a6Fm.js

@@ -0,0 +1,51 @@
+import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
+//#region src/blocks/notifications/client.ts
+/** The default badge number: the items whose `readAt` is `null`. */
+const unreadCount = (items) => items.filter((item) => typeof item === "object" && item !== null && "readAt" in item && item.readAt === null).length;
+/**
+* The signed-in user's notifications, kept current: loads them, then loads
+* again after each broadcast on `topic` and after the channel rejoins.
+*/
+function createNotificationsController(options) {
+	const countOf = options.count ?? unreadCount;
+	return defineController({
+		items: void 0,
+		count: 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			try {
+				const merged = (await Promise.all([options.load, ...options.sources ?? []].map((source) => source()))).flat();
+				const items = options.sort ? [...merged].sort(options.sort) : merged;
+				state.set({
+					items,
+					count: countOf(items),
+					error: void 0
+				});
+			} catch (cause) {
+				state.set({ error: cause });
+			}
+		};
+		return {
+			actions: { refresh },
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+				if (!options.topic) return;
+				const { leave } = options.ports.topic(options.topic, {
+					onMessage: (event, payload) => {
+						options.onMessage?.(event, payload);
+						refresh();
+					},
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				});
+				return leave;
+			})
+		};
+	});
+}
+//#endregion
+export { unreadCount as n, createNotificationsController as t };

package/dist/client-BtBkVSk2.d.ts

@@ -0,0 +1,108 @@
+import { b as DbError, f as Result, t as AsyncResult } from "./result-Cj3yWhjH.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "./standard-C3_AAF3g.js";
+import { n as BlockOptions } from "./block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "./block-hooks-C_WaodoA.js";
+import { n as ExtraFields, r as FieldsOf } from "./block-fields-5UA84ZUg.js";
+import { n as Controller, t as AuthPort } from "./controller-CCb9tHw_.js";
+import { t as RankNeighbors } from "./rank-result-Dngpt2n5.js";
+//#region src/blocks/tags/tags.d.ts
+interface TagsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockOptions {
+  /**
+   * A Standard Schema for the tag's extra columns
+   * (`blocks.tags.options.extraColumns`), keyed by database name. It types
+   * and parses them on reads, and validates them on `create` and `update`.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Tags<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A tag. `F` types the extra columns the `fields` schema describes. */
+interface Tag<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly name: string;
+  readonly slug: string;
+  /** Its rank key among the tenant's tags of the same kind, when it has one. */
+  readonly rank?: string;
+  /** Set on the tags `list` and `forSubject` return. */
+  readonly kind?: string;
+  readonly color?: string;
+  readonly description?: string;
+  /** The extra columns, keyed by database name. */
+  readonly fields: ExtraFields<F>;
+}
+interface Tags<F extends object = Record<never, never>> {
+  /** Creates a tag; `fields` sets its extra columns. */
+  create(organizationId: string, kind: string, name: string, color?: string, description?: string, fields?: Partial<F>): AsyncResult<Tag<F>>;
+  /** Renames a tag (`name` null keeps it) and sets the extra columns `fields` names. */
+  update(id: string, name: string | null, fields?: Partial<F>): AsyncResult<boolean>;
+  /**
+   * Moves a tag between the tags with rank keys `previous` and `next`.
+   * Resolves to its new key.
+   */
+  reorder(id: string, neighbors: RankNeighbors): AsyncResult<string>;
+  delete(id: string): AsyncResult<boolean>;
+  tag(organizationId: string, subjectType: string, subjectId: string, tagId: string): AsyncResult<boolean>;
+  untag(organizationId: string, subjectType: string, subjectId: string, tagId: string): AsyncResult<boolean>;
+  /** The tenant's tags of `kind` (every kind without it), in rank order. */
+  list(organizationId: string, kind?: string): AsyncResult<readonly Tag<F>[]>;
+  /** The tags on one subject, in rank order; the caller must be able to read it. */
+  forSubject(organizationId: string, subjectType: string, subjectId: string): AsyncResult<readonly Tag<F>[]>;
+}
+/** The `tags` SQL module as typed calls. */
+declare function createTags<S extends StandardSchemaV1 | undefined = undefined>(options: TagsOptions<S>): Tags<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/tags/client.d.ts
+/** A tag change on the subject that committed, for `onChanged`. */
+type TagChange = {
+  readonly kind: "added";
+  readonly tag: Tag;
+  readonly created: boolean;
+} | {
+  readonly kind: "removed";
+  readonly tag: Tag;
+};
+interface TagInputControllerOptions {
+  readonly client: Pick<Tags, "list" | "forSubject" | "tag" | "untag" | "create">;
+  readonly auth: AuthPort;
+  /** The organization; the input waits without one. */
+  readonly organizationId: string | null;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  /** The kind of tags the input offers and creates, such as `customer`. */
+  readonly kind: string;
+  /** Runs after a tag was added or removed. A throw is kept in `error`. */
+  readonly onChanged?: (change: TagChange) => void | Promise<void>;
+}
+interface TagInputSnapshot {
+  /** The subject's tags, in rank order; `undefined` until the first load. */
+  readonly tags: readonly Tag[] | undefined;
+  /** Every tag of the kind, for suggestions; `undefined` until the first load. */
+  readonly available: readonly Tag[] | undefined;
+  /** The tag ids, or the names of tags being created, with a write in flight. */
+  readonly pending: readonly string[];
+  readonly error: DbError | undefined;
+}
+interface TagInputActions {
+  /** Adds an existing tag, shown at once and taken back when it fails. */
+  readonly add: (tagId: string) => Promise<Result<Tag>>;
+  /** Removes a tag, hidden at once and put back when it fails. */
+  readonly remove: (tagId: string) => Promise<Result<boolean>>;
+  /**
+   * Adds the tag called `name`: an existing one of the kind with the same
+   * name (ignoring case), or a new one, which needs `tags.manage`.
+   */
+  readonly create: (name: string) => Promise<Result<Tag>>;
+  readonly refresh: () => Promise<void>;
+}
+type TagInputController = Controller<TagInputSnapshot, TagInputActions>;
+/**
+ * One subject's tags for a tag input: the tags on it, every tag of the
+ * kind for suggestions, and `add`, `remove` and `create`, which show the
+ * change at once.
+ */
+declare function createTagInputController(options: TagInputControllerOptions): TagInputController;
+//#endregion
+export { TagInputSnapshot as a, Tags as c, TagInputControllerOptions as i, TagsOptions as l, TagInputActions as n, createTagInputController as o, TagInputController as r, Tag as s, TagChange as t, createTags as u };

package/dist/client-ByGlM0YF.d.ts

@@ -0,0 +1,101 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-Cj3yWhjH.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "./block-hooks-C_WaodoA.js";
+import { n as Controller, t as AuthPort } from "./controller-CCb9tHw_.js";
+//#region src/blocks/onboarding/onboarding.d.ts
+type ChecklistScope = "user" | "organization";
+/** One step. `events` completes it when the outbox records one of those types. */
+interface ChecklistStep<Id extends string = string> {
+  readonly id: Id;
+  readonly title?: string;
+  readonly description?: string;
+  /** Where the step is done in the app, for a "Start" link. */
+  readonly href?: string;
+  readonly events?: readonly string[];
+}
+interface ChecklistSpec<Id extends string, Scope extends ChecklistScope> {
+  readonly id: string;
+  /** `user` tracks each user; `organization` tracks each tenant. */
+  readonly scope: Scope;
+  readonly steps: readonly ChecklistStep<Id>[];
+}
+interface OnboardingOptions extends BlockOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Onboarding>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A step with the subject's progress. */
+interface StepProgress<Id extends string> extends ChecklistStep<Id> {
+  readonly completed: boolean;
+  readonly completedAt: Temporal.Instant | undefined;
+  readonly completedBy: string | undefined;
+}
+interface ChecklistProgress<Id extends string> {
+  readonly steps: readonly StepProgress<Id>[];
+  readonly completed: number;
+  readonly total: number;
+  /** Every step is complete. */
+  readonly done: boolean;
+  /** The first step not done yet. */
+  readonly next: StepProgress<Id> | undefined;
+}
+/** The organization for an organization checklist; nothing for a user one. */
+type ChecklistSubject<Scope extends ChecklistScope> = Scope extends "organization" ? [organizationId: string] : [];
+/** The onboarding block: progress through any checklist `defineChecklist` declared. */
+interface Onboarding {
+  /** The subject's progress: the caller's for a user checklist, the organization's otherwise. */
+  progress<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, ...subject: ChecklistSubject<Scope>): AsyncResult<ChecklistProgress<Id>>;
+  /** Marks a step done; `false` when it already was. */
+  complete<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
+  /** Marks a step not done; `false` when it wasn't. */
+  reset<Id extends string, Scope extends ChecklistScope>(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
+}
+/** A checklist `defineChecklist` checked; pass it to the onboarding client's methods. */
+type Checklist<Id extends string, Scope extends ChecklistScope> = ChecklistSpec<Id, Scope>;
+/**
+ * Declares an onboarding checklist. Pass the result to
+ * `blocks.onboarding.options.checklists` so the database knows its
+ * steps, and to the methods of `createOnboarding` to read and complete them.
+ */
+declare function defineChecklist<const Id extends string, const Scope extends ChecklistScope>(spec: ChecklistSpec<Id, Scope>): Checklist<Id, Scope>;
+/**
+ * The onboarding block: reads and completes the steps of the checklists in
+ * `blocks.onboarding.options.checklists`, for the caller or an organization.
+ */
+declare function createOnboarding(options: OnboardingOptions): Onboarding;
+//#endregion
+//#region src/blocks/onboarding/client.d.ts
+/** The calls the controller makes for one checklist; `createOnboarding` fits. */
+interface OnboardingControllerClient<Id extends string, Scope extends ChecklistScope> {
+  progress(checklist: Checklist<Id, Scope>, ...subject: ChecklistSubject<Scope>): AsyncResult<ChecklistProgress<Id>>;
+  complete(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
+  reset(checklist: Checklist<Id, Scope>, step: Id, ...subject: ChecklistSubject<Scope>): AsyncResult<boolean>;
+}
+interface OnboardingControllerOptions<Id extends string, Scope extends ChecklistScope> {
+  /** `createOnboarding({ transport })`. */
+  readonly client: OnboardingControllerClient<Id, Scope>;
+  /** The checklist, from `defineChecklist`. */
+  readonly checklist: Checklist<Id, Scope>;
+  readonly auth: AuthPort;
+  /** The organization, for an organization checklist; it waits without one. */
+  readonly organizationId?: string | null;
+}
+interface OnboardingSnapshot<Id extends string> {
+  /** `undefined` until the first load. */
+  readonly progress: ChecklistProgress<Id> | undefined;
+  readonly error: DbError | undefined;
+}
+interface OnboardingActions<Id extends string> {
+  /** Marks a step done, then loads the progress again. */
+  readonly complete: (step: Id) => Promise<void>;
+  readonly reset: (step: Id) => Promise<void>;
+  readonly refresh: () => Promise<void>;
+}
+type OnboardingController<Id extends string> = Controller<OnboardingSnapshot<Id>, OnboardingActions<Id>>;
+/** A checklist's progress for the signed-in user, or for an organization. */
+declare function createOnboardingController<Id extends string, Scope extends ChecklistScope>(options: OnboardingControllerOptions<Id, Scope>): OnboardingController<Id>;
+//#endregion
+export { defineChecklist as _, OnboardingSnapshot as a, ChecklistProgress as c, ChecklistStep as d, ChecklistSubject as f, createOnboarding as g, StepProgress as h, OnboardingControllerOptions as i, ChecklistScope as l, OnboardingOptions as m, OnboardingController as n, createOnboardingController as o, Onboarding as p, OnboardingControllerClient as r, Checklist as s, OnboardingActions as t, ChecklistSpec as u };

package/dist/client-BzCv4kKE.js

@@ -0,0 +1,65 @@
+import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
+import { n as watchRun, t as firstError } from "./run-watch-CQRdpy-f.js";
+//#region src/blocks/workflow-builder/client.ts
+/** The definitions the signed-in user may read and the step library. */
+function createWorkflowBuilderController(options) {
+	const tenant = options.tenant ?? null;
+	return defineController({
+		definitions: void 0,
+		steps: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			const run = state.run();
+			const [listed, library] = await Promise.all([options.client.definitions.list(tenant ?? void 0), options.client.steps.list()]);
+			if (run !== state.run()) return;
+			state.set({
+				...listed.ok ? { definitions: listed.data } : {},
+				...library.ok ? { steps: library.data } : {},
+				error: firstError(listed, library)
+			});
+		};
+		return {
+			actions: { refresh },
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+			})
+		};
+	});
+}
+const NO_NODES = {};
+/**
+* A run and the status of each of its nodes, loaded again on each message
+* on `workflow-run:<id>` (run status changes and node records).
+*/
+function createWorkflowCanvasRunController(options) {
+	const { client } = options;
+	const run = options.run ?? "";
+	return defineController({
+		run: void 0,
+		nodes: NO_NODES,
+		error: void 0,
+		status: "closed"
+	}, (state) => {
+		const watch = watchRun({
+			...options,
+			load: async () => {
+				const [found, listed] = await Promise.all([client.runs.get(run), client.nodeRuns.list(run)]);
+				return {
+					id: found.ok ? found.data?.id ?? null : null,
+					patch: {
+						...found.ok ? { run: found.data } : {},
+						...listed.ok ? { nodes: Object.fromEntries(listed.data.map((node) => [node.node, node])) } : {},
+						error: firstError(found, listed)
+					}
+				};
+			}
+		}, state);
+		return {
+			actions: { refresh: watch.refresh },
+			start: watch.start
+		};
+	});
+}
+//#endregion
+export { createWorkflowCanvasRunController as n, createWorkflowBuilderController as t };

package/dist/client-C-2ajnhM.js

@@ -0,0 +1,89 @@
+import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
+import { n as watchRun } from "./run-watch-CQRdpy-f.js";
+//#region src/blocks/workflows/client.ts
+/**
+* The runs the signed-in user may read, newest first, loaded again when a
+* run in the tenant changes status.
+*/
+function createWorkflowRunsController(options) {
+	const tenant = options.tenant ?? null;
+	const { definition, limit } = options;
+	const runStatus = options.status;
+	return defineController({
+		runs: void 0,
+		error: void 0,
+		status: "closed"
+	}, (state) => {
+		const refresh = async () => {
+			const run = state.run();
+			const result = await options.client.runs.list({
+				...tenant === null ? {} : { tenant },
+				...definition === void 0 ? {} : { definition },
+				...runStatus === void 0 ? {} : { status: runStatus },
+				...limit === void 0 ? {} : { limit }
+			});
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				runs: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: { refresh },
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+				if (tenant === null) return;
+				return options.ports.topic(`workflow-runs:${tenant}`, {
+					onMessage: () => void refresh(),
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				}).leave;
+			})
+		};
+	});
+}
+/**
+* One run by its id or its engine's id, loaded again on each status change
+* broadcast on `workflow-run:<id>`.
+*/
+function createWorkflowRunController(options) {
+	const { client, run } = options;
+	return defineController({
+		run: void 0,
+		error: void 0,
+		status: "closed"
+	}, (state) => {
+		const watch = watchRun({
+			...options,
+			load: async () => {
+				const result = await client.runs.get(run ?? "");
+				return result.ok ? {
+					id: result.data?.id ?? null,
+					patch: {
+						run: result.data,
+						error: void 0
+					}
+				} : {
+					id: null,
+					patch: { error: result.error }
+				};
+			}
+		}, state);
+		return {
+			actions: {
+				refresh: watch.refresh,
+				cancel: async () => {
+					if (run === null) return;
+					const result = await client.runs.requestCancel(run);
+					if (result.ok) await watch.refresh();
+					else state.set({ error: result.error });
+				}
+			},
+			start: watch.start
+		};
+	});
+}
+//#endregion
+export { createWorkflowRunsController as n, createWorkflowRunController as t };

package/dist/client-C3dLIsJv.d.ts

@@ -0,0 +1,122 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult, w as ErrorMapper } from "./result-Cj3yWhjH.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "./standard-C3_AAF3g.js";
+import { t as BlockTransport } from "./block-transport-NbUJygA7.js";
+import { r as BlockTemporalOptions } from "./block-helpers-7pMBVsE6.js";
+import { n as BlockHooks } from "./block-hooks-C_WaodoA.js";
+import { r as FieldsOf } from "./block-fields-5UA84ZUg.js";
+import { p as SubscriptionStatus } from "./topic-Dgs-eSYQ.js";
+import { n as TopicPort } from "./watch-topic-D-rpUg5n.js";
+import { n as Controller, t as AuthPort } from "./controller-CCb9tHw_.js";
+//#region src/blocks/announcements/announcements.d.ts
+type AnnouncementSeverity = "info" | "success" | "warning" | "critical";
+/**
+ * Who sees it: everyone, members of some tenants, members with some roles,
+ * or tenants on some plans (entitlement lookup keys, with the entitlements
+ * module).
+ */
+type AnnouncementAudience = {
+  readonly type: "all";
+} | {
+  readonly type: "tenant";
+  readonly organizationIds: readonly string[];
+} | {
+  readonly type: "role";
+  readonly roles: readonly string[];
+} | {
+  readonly type: "plan";
+  readonly plans: readonly string[];
+};
+interface Announcement {
+  readonly id: string;
+  readonly title: string;
+  readonly body: string;
+  readonly severity: AnnouncementSeverity;
+  readonly href: string | undefined;
+  readonly startsAt: Temporal.Instant;
+  readonly endsAt: Temporal.Instant | undefined;
+  readonly dismissible: boolean;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** An announcement as staff see it, with its audience. */
+interface ManagedAnnouncement extends Announcement {
+  readonly audience: AnnouncementAudience;
+  readonly createdBy: string | undefined;
+}
+interface AnnouncementInput {
+  readonly title: string;
+  /** Plain text or Markdown; the app renders it. */
+  readonly body?: string;
+  readonly severity?: AnnouncementSeverity;
+  /** A link for "Learn more": `https://` or a path. */
+  readonly href?: string | null;
+  readonly audience?: AnnouncementAudience;
+  readonly startsAt?: Temporal.Instant;
+  readonly endsAt?: Temporal.Instant | null;
+  readonly dismissible?: boolean;
+}
+interface AnnouncementsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  /**
+   * A Standard Schema for the announcement columns the app adds
+   * (`blocks.announcements.options.extraColumns`), keyed by column name. It
+   * types and parses them on every read, and validates them on `publish`
+   * and `update`, which return a `validation` error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Announcements<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. Default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** `F` is the extra fields `options.fields` describes. */
+interface Announcements<F extends object = Record<never, never>> {
+  /** The caller's live, undismissed announcements; pass the active tenant for tenant, role and plan audiences. */
+  listActive(organizationId?: string | null): AsyncResult<readonly (Announcement & F)[]>;
+  /** Hides one for the caller; `false` when it was hidden already. */
+  dismiss(announcementId: string): AsyncResult<boolean>;
+  /** Every announcement; needs `announcements.manage` on the platform. */
+  list(): AsyncResult<readonly (ManagedAnnouncement & F)[]>;
+  /** Keys besides the input's own are the announcement's extra columns. */
+  publish(input: AnnouncementInput & Partial<F>): AsyncResult<ManagedAnnouncement & F>;
+  update(announcementId: string, input: Partial<AnnouncementInput> & Partial<F>): AsyncResult<ManagedAnnouncement & F>;
+  remove(announcementId: string): AsyncResult<boolean>;
+}
+declare function createAnnouncements<S extends StandardSchemaV1 | undefined = undefined>(options: AnnouncementsOptions<S>): Announcements<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/announcements/client.d.ts
+interface AnnouncementsControllerOptions {
+  readonly client: Pick<Announcements, "listActive" | "dismiss">;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The active tenant, for tenant, role and plan audiences. */
+  readonly organizationId?: string | null;
+  /** The topic the module broadcasts to (`blockConfig.announcements.options.topic` from `blocks.generated.ts`); `null` loads once. */
+  readonly topic?: string | null;
+}
+interface AnnouncementsSnapshot {
+  /** `undefined` until the first load. */
+  readonly items: readonly Announcement[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AnnouncementsActions {
+  /** Hides one for the user, then drops it from `items`. */
+  readonly dismiss: (announcementId: string) => Promise<void>;
+  readonly refresh: () => Promise<void>;
+}
+type AnnouncementsController = Controller<AnnouncementsSnapshot, AnnouncementsActions>;
+/**
+ * The signed-in user's live announcements, loaded again whenever staff
+ * publish, change or remove one.
+ */
+declare function createAnnouncementsController(options: AnnouncementsControllerOptions): AnnouncementsController;
+//#endregion
+export { createAnnouncementsController as a, AnnouncementInput as c, AnnouncementsOptions as d, ManagedAnnouncement as f, AnnouncementsSnapshot as i, AnnouncementSeverity as l, AnnouncementsController as n, Announcement as o, createAnnouncements as p, AnnouncementsControllerOptions as r, AnnouncementAudience as s, AnnouncementsActions as t, Announcements as u };