@wssto2/vue-core 0.2.0 → 0.4.0

package/dist/modules/identity/routes.d.ts

@@ -0,0 +1,118 @@
+import { type ListResult } from "../../client";
+import type { ActivityRow, ChangeRow, PendingEmail, ProfileResponse, SessionList, SessionResponse, SignInRow, UnlockResult, UserDetail, UserRow } from "./entities";
+export declare const identityRoutes: {
+    readonly login: import("../../client").ApiRoute<{
+        login: string;
+        password: string;
+    }, SessionResponse>;
+    readonly refresh: import("../../client").ApiRoute<{
+        refresh_token: string;
+    }, SessionResponse>;
+    readonly logout: import("../../client").ApiRoute<void, void>;
+    readonly me: import("../../client").ApiRoute<void, SessionResponse>;
+    readonly changeLocale: import("../../client").ApiRoute<{
+        locale: string;
+    }, void>;
+    readonly loginAs: import("../../client").ApiRoute<{
+        user_id: number;
+    }, SessionResponse>;
+    readonly loginAsReturn: import("../../client").ApiRoute<void, SessionResponse>;
+    readonly usersList: import("../../client").ApiRoute<{
+        view?: "inactive" | "all" | "locked" | "active" | undefined;
+        search?: string | undefined;
+        order_col?: string | undefined;
+        order_dir?: string | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<UserRow>>;
+    readonly usersShow: import("../../client").ApiRoute<{
+        id: number;
+    }, UserDetail>;
+    readonly usersCreate: import("../../client").ApiRoute<{
+        login: string;
+        name: string;
+        email: string;
+        locale: string;
+        password: string;
+        phone?: string | undefined;
+    }, UserDetail>;
+    readonly usersUpdate: import("../../client").ApiRoute<{
+        id: number;
+        login: string;
+        name: string;
+        email: string;
+        locale: string;
+        phone?: string | undefined;
+    }, UserDetail>;
+    readonly usersSetPassword: import("../../client").ApiRoute<{
+        id: number;
+        password: string;
+    }, void>;
+    readonly usersDeactivate: import("../../client").ApiRoute<{
+        id: number;
+    }, void>;
+    readonly usersActivate: import("../../client").ApiRoute<{
+        id: number;
+    }, void>;
+    readonly usersUnlock: import("../../client").ApiRoute<{
+        id: number;
+    }, UnlockResult>;
+    readonly usersSignins: import("../../client").ApiRoute<{
+        id: number;
+        view?: "all" | "failed" | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<SignInRow>>;
+    readonly usersChanges: import("../../client").ApiRoute<{
+        id: number;
+        view?: "details" | "all" | "access" | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<ChangeRow>>;
+    readonly usersActivity: import("../../client").ApiRoute<{
+        id: number;
+        area?: string | undefined;
+        from?: string | undefined;
+        to?: string | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<ActivityRow>>;
+    readonly usersSessions: import("../../client").ApiRoute<{
+        id: number;
+    }, SessionList>;
+    readonly usersRevokeSession: import("../../client").ApiRoute<{
+        id: number;
+        session_id: number;
+    }, void>;
+    readonly usersRevokeSessions: import("../../client").ApiRoute<{
+        id: number;
+    }, void>;
+    readonly profileShow: import("../../client").ApiRoute<void, ProfileResponse>;
+    readonly profileUpdate: import("../../client").ApiRoute<{
+        name: string;
+        phone?: string | undefined;
+    }, ProfileResponse>;
+    readonly profileChangePassword: import("../../client").ApiRoute<{
+        current_password: string;
+        new_password: string;
+        new_password_confirmation: string;
+    }, void>;
+    readonly profileRequestEmail: import("../../client").ApiRoute<{
+        email: string;
+        current_password: string;
+    }, PendingEmail>;
+    readonly profileResendEmail: import("../../client").ApiRoute<void, PendingEmail>;
+    readonly profileConfirmEmail: import("../../client").ApiRoute<{
+        code: string;
+    }, ProfileResponse>;
+    readonly profileCancelEmail: import("../../client").ApiRoute<void, void>;
+    readonly profileSignins: import("../../client").ApiRoute<{
+        view?: "all" | "failed" | undefined;
+        page?: number | undefined;
+        per_page?: number | undefined;
+    }, ListResult<SignInRow>>;
+    readonly profileSessions: import("../../client").ApiRoute<void, SessionList>;
+    readonly profileRevokeSession: import("../../client").ApiRoute<{
+        session_id: number;
+    }, void>;
+};

package/dist/modules/identity/schemas.d.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+export declare const ActivityInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    area: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ActivityInput = z.infer<typeof ActivityInputSchema>;
+export declare const ChangeLocaleInputSchema: z.ZodObject<{
+    locale: z.ZodString;
+}, z.core.$strip>;
+export type ChangeLocaleInput = z.infer<typeof ChangeLocaleInputSchema>;
+export declare const ChangePasswordInputSchema: z.ZodObject<{
+    current_password: z.ZodString;
+    new_password: z.ZodString;
+    new_password_confirmation: z.ZodString;
+}, z.core.$strip>;
+export type ChangePasswordInput = z.infer<typeof ChangePasswordInputSchema>;
+export declare const ChangeViewSchema: z.ZodEnum<{
+    details: "details";
+    all: "all";
+    access: "access";
+}>;
+export type ChangeView = z.infer<typeof ChangeViewSchema>;
+export declare const ChangesInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    view: z.ZodOptional<z.ZodEnum<{
+        details: "details";
+        all: "all";
+        access: "access";
+    }>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ChangesInput = z.infer<typeof ChangesInputSchema>;
+export declare const ConfirmEmailInputSchema: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+export type ConfirmEmailInput = z.infer<typeof ConfirmEmailInputSchema>;
+export declare const CreateUserInputSchema: z.ZodObject<{
+    login: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+    locale: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type CreateUserInput = z.infer<typeof CreateUserInputSchema>;
+export declare const UserViewSchema: z.ZodEnum<{
+    inactive: "inactive";
+    all: "all";
+    locked: "locked";
+    active: "active";
+}>;
+export type UserView = z.infer<typeof UserViewSchema>;
+export declare const ListUsersInputSchema: z.ZodObject<{
+    view: z.ZodOptional<z.ZodEnum<{
+        inactive: "inactive";
+        all: "all";
+        locked: "locked";
+        active: "active";
+    }>>;
+    search: z.ZodOptional<z.ZodString>;
+    order_col: z.ZodOptional<z.ZodString>;
+    order_dir: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListUsersInput = z.infer<typeof ListUsersInputSchema>;
+export declare const LoginAsInputSchema: z.ZodObject<{
+    user_id: z.ZodNumber;
+}, z.core.$strip>;
+export type LoginAsInput = z.infer<typeof LoginAsInputSchema>;
+export declare const LoginInputSchema: z.ZodObject<{
+    login: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type LoginInput = z.infer<typeof LoginInputSchema>;
+export declare const OwnSessionInputSchema: z.ZodObject<{
+    session_id: z.ZodNumber;
+}, z.core.$strip>;
+export type OwnSessionInput = z.infer<typeof OwnSessionInputSchema>;
+export declare const SignInViewSchema: z.ZodEnum<{
+    all: "all";
+    failed: "failed";
+}>;
+export type SignInView = z.infer<typeof SignInViewSchema>;
+export declare const OwnSignInsInputSchema: z.ZodObject<{
+    view: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        failed: "failed";
+    }>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type OwnSignInsInput = z.infer<typeof OwnSignInsInputSchema>;
+export declare const RefreshInputSchema: z.ZodObject<{
+    refresh_token: z.ZodString;
+}, z.core.$strip>;
+export type RefreshInput = z.infer<typeof RefreshInputSchema>;
+export declare const RequestEmailInputSchema: z.ZodObject<{
+    email: z.ZodString;
+    current_password: z.ZodString;
+}, z.core.$strip>;
+export type RequestEmailInput = z.infer<typeof RequestEmailInputSchema>;
+export declare const SetPasswordInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type SetPasswordInput = z.infer<typeof SetPasswordInputSchema>;
+export declare const SignInsInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    view: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        failed: "failed";
+    }>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SignInsInput = z.infer<typeof SignInsInputSchema>;
+export declare const UpdateProfileInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UpdateProfileInput = z.infer<typeof UpdateProfileInputSchema>;
+export declare const UpdateUserInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    login: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodString;
+    phone: z.ZodOptional<z.ZodString>;
+    locale: z.ZodString;
+}, z.core.$strip>;
+export type UpdateUserInput = z.infer<typeof UpdateUserInputSchema>;
+export declare const UserInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+export type UserInput = z.infer<typeof UserInputSchema>;
+export declare const UserSessionInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    session_id: z.ZodNumber;
+}, z.core.$strip>;
+export type UserSessionInput = z.infer<typeof UserSessionInputSchema>;

package/dist/modules/notification/entities.d.ts

@@ -0,0 +1,46 @@
+export type CategorySettings = {
+    category: string;
+    email: Setting;
+};
+export type Item = {
+    id: number;
+    category: string;
+    title: string;
+    body: string;
+    link: string;
+    data: Record<string, string>;
+    read_at: string | null;
+    created_at: string;
+};
+export type Page = {
+    items: Item[];
+    has_more: boolean;
+};
+export type Preferences = {
+    email_available: boolean;
+    categories: CategorySettings[];
+    quiet_hours: QuietHours;
+    time_zone: string;
+};
+export type QuietHours = {
+    enabled: boolean;
+    start: number;
+    end: number;
+};
+export type Setting = {
+    enabled: boolean;
+    source: Source;
+};
+export type Source = "enforced" | "person" | "default";
+export type StreamEvent = {
+    type: StreamKind;
+    notification?: Item | null;
+    read_ids?: number[];
+    all_read?: boolean;
+    read_up_to_id?: number;
+    unread_count: number;
+};
+export type StreamKind = "created" | "read" | "unread";
+export type UnreadCount = {
+    unread_count: number;
+};

package/dist/modules/notification/routes.d.ts

@@ -0,0 +1,26 @@
+import type { CategorySettings, Page, Preferences, QuietHours, UnreadCount } from "./entities";
+export declare const notificationRoutes: {
+    readonly list: import("../../client").ApiRoute<{
+        before_id?: number | undefined;
+        limit?: number | undefined;
+    }, Page>;
+    readonly unread: import("../../client").ApiRoute<void, UnreadCount>;
+    readonly read: import("../../client").ApiRoute<{
+        id: number;
+    }, UnreadCount>;
+    readonly readAll: import("../../client").ApiRoute<{
+        up_to_id: number;
+    }, UnreadCount>;
+    readonly stream: import("../../client").RawRoute;
+    readonly test: import("../../client").ApiRoute<void, void>;
+    readonly preferences: import("../../client").ApiRoute<void, Preferences>;
+    readonly preferencesSetEmail: import("../../client").ApiRoute<{
+        category: string;
+        email: boolean | null;
+    }, CategorySettings>;
+    readonly quietHours: import("../../client").ApiRoute<{
+        enabled: boolean;
+        start: number;
+        end: number;
+    }, QuietHours>;
+};

package/dist/modules/notification/schemas.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const ListQuerySchema: z.ZodObject<{
+    before_id: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListQuery = z.infer<typeof ListQuerySchema>;
+export declare const MarkAllInputSchema: z.ZodObject<{
+    up_to_id: z.ZodNumber;
+}, z.core.$strip>;
+export type MarkAllInput = z.infer<typeof MarkAllInputSchema>;
+export declare const QuietHoursInputSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    start: z.ZodNumber;
+    end: z.ZodNumber;
+}, z.core.$strip>;
+export type QuietHoursInput = z.infer<typeof QuietHoursInputSchema>;
+export declare const ReadInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+export type ReadInput = z.infer<typeof ReadInputSchema>;
+export declare const SetEmailInputSchema: z.ZodObject<{
+    category: z.ZodString;
+    email: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SetEmailInput = z.infer<typeof SetEmailInputSchema>;

package/dist/{navigation-B33ikiCS.js → navigation-Cm3iChlR.js}

@@ -1,6 +1,7 @@
 import { computed as k } from "vue";
 import { d as y } from "./context-Ch1r4fdN.js";
-function x(l, r = {}) {
+import { h as N } from "./platform-q3cjODLx.js";
+function F(l, a = {}) {
   const i = /* @__PURE__ */ new Map(), o = [];
   for (const e of l) {
     const { destination: s } = e.binding, u = i.get(s);
@@ -8,30 +9,30 @@ function x(l, r = {}) {
       o.push(`The destination "${s}" is bound twice: by feature "${u.feature}" and by feature "${e.feature}".`);
       continue;
     }
-    r.known && !r.known.includes(s) && o.push(`Feature "${e.feature}" binds the destination "${s}", which the backend's navigation does not contain.`), i.set(s, e);
+    a.known && !a.known.includes(s) && o.push(`Feature "${e.feature}" binds the destination "${s}", which the backend's navigation does not contain.`), i.set(s, e);
   }
-  for (const e of r.required ?? [])
+  for (const e of a.required ?? [])
     i.has(e) || o.push(`The destination "${e}" is required but no feature binds it.`);
   return { destinations: i, issues: o };
 }
-function C(l) {
-  const { session: r, router: i, i18n: o, destinations: e } = l, s = (t) => o.te(t.i18n) ? o.t(t.i18n) : t.i18n;
-  function u(t, a) {
+function M(l) {
+  const { session: a, router: i, i18n: o, destinations: e } = l, s = (t) => o.te(t.i18n) ? o.t(t.i18n) : t.i18n;
+  function u(t, r) {
     return t.flatMap((n, f) => {
-      const c = `${a}/${n.route ?? f}`, d = u(n.children ?? [], c);
+      const c = `${r}/${n.route ?? f}`, d = u(n.children ?? [], c);
       if (n.route === void 0) return d.length > 0 ? [h(n, c, null, d, !1)] : [];
       const v = e.get(n.route);
       if (!v) return [];
-      const { to: b, within: g = [] } = v.binding, p = g.some(($) => i.currentRoute.value.matched.some((w) => w.name === $));
-      return [h(n, c, b, d, p || m(b))];
+      const { to: m, within: g = [] } = v.binding, p = g.some(($) => i.currentRoute.value.matched.some((w) => w.name === $));
+      return [h(n, c, m, d, p || b(m))];
     });
   }
-  function m(t) {
-    const { matched: a } = i.resolve(t), n = a[a.length - 1];
+  function b(t) {
+    const { matched: r } = i.resolve(t), n = r[r.length - 1];
     return n !== void 0 && i.currentRoute.value.matched.includes(n);
   }
-  const h = (t, a, n, f, c) => ({
-    key: a,
+  const h = (t, r, n, f, c) => ({
+    key: r,
     label: s(t),
     icon: t.icon ?? null,
     to: n,
@@ -39,14 +40,14 @@ function C(l) {
     children: f
   });
   return k(() => {
-    const t = r.state.value;
-    return t.status === "authenticated" ? u(t.navigation ?? [], "") : [];
+    const t = N(a.state.value);
+    return t ? u(t.navigation ?? [], "") : [];
   });
 }
-const [F, M] = y("vue-core.navigation");
+const [R, T] = y("vue-core.navigation");
 export {
-  x as b,
-  C as c,
-  F as n,
-  M as u
+  F as b,
+  M as c,
+  R as n,
+  T as u
 };

package/dist/neighbors-DpaIMQAL.js

@@ -0,0 +1,86 @@
+import { ref as P, shallowRef as z, watch as X, getCurrentScope as j, onScopeDispose as B } from "vue";
+import { useRoute as F } from "vue-router";
+import { i as M } from "./error-CD7x0Jrz.js";
+import { L as I, o as J, d as Q, e as N, q as U } from "./http-CNcDHSOj.js";
+const V = 8;
+function te(s, r) {
+  const v = F(), R = r.from ?? (() => typeof v.query[I] == "string" ? v.query[I] : null), D = r.stateKey ?? "query", y = P(null), p = P(0), h = z(null), d = z(null), b = P(!1), S = z(null), n = /* @__PURE__ */ new Map();
+  let m = 0, k = new AbortController(), E = !1;
+  function q(w, g, l) {
+    const f = { ...w, page: g }, c = U(f);
+    let a = n.get(c);
+    for (a ? n.delete(c) : (a = (async () => s.load(f, { signal: l }))(), a.catch(() => {
+      n.get(c) === a && n.delete(c);
+    })), n.set(c, a); n.size > V; ) n.delete(n.keys().next().value);
+    return a.catch((e) => {
+      if (M(e)) throw e;
+      return null;
+    });
+  }
+  function K() {
+    y.value = null, h.value = null, d.value = null, p.value = 0, S.value = null;
+  }
+  async function T() {
+    const w = ++m, g = k.signal, l = Q(s, R()), f = r.current();
+    if (!l || f === null || f === void 0 || f === "") {
+      K(), b.value = !1;
+      return;
+    }
+    b.value = !0, h.value = null, d.value = null;
+    const c = (e) => e ? e.rows.findIndex((t) => String(s.key(t)) === String(f)) : -1, a = (e, t) => {
+      const o = N(s, { ...l, page: e });
+      return { key: t, to: { name: v.name ?? void 0, params: { ...v.params, [r.param]: String(t) }, query: { ...v.query, [I]: o }, hash: v.hash } };
+    };
+    try {
+      let e = l.page, t = await q(l, e, g), o = c(t);
+      for (const i of [e - 1, e + 1]) {
+        if (o !== -1 || !t || i < 1 || i > t.lastPage) continue;
+        const u = await q(l, i, g), _ = c(u);
+        u && _ !== -1 && (e = i, t = u, o = _);
+      }
+      if (w !== m) return;
+      if (!t || o === -1) {
+        K();
+        return;
+      }
+      const O = t.pageSize || l.pageSize, C = t.rows;
+      let A = null;
+      if (o > 0) A = a(e, s.key(C[o - 1]));
+      else if (e > 1) {
+        const i = await q(l, e - 1, g), u = i?.rows[i.rows.length - 1];
+        u !== void 0 && (A = a(e - 1, s.key(u)));
+      }
+      let L = null;
+      if (o < C.length - 1) L = a(e, s.key(C[o + 1]));
+      else if (e < t.lastPage) {
+        const u = (await q(l, e + 1, g))?.rows[0];
+        u !== void 0 && (L = a(e + 1, s.key(u)));
+      }
+      if (w !== m) return;
+      p.value = t.total, y.value = (e - 1) * O + o + 1, h.value = A, d.value = L;
+      const x = r.list;
+      S.value = typeof x == "string" ? x : { ...x, query: { ...x.query, [D]: N(s, { ...l, page: e }) } };
+    } catch (e) {
+      if (!M(e)) throw e;
+    } finally {
+      w === m && (b.value = !1);
+    }
+  }
+  const G = X([R, r.current], T, { immediate: !0 });
+  function H() {
+    E || (E = !0, m++, k.abort(), G(), n.clear());
+  }
+  return j() && B(H), J(() => {
+    k.abort(), k = new AbortController(), n.clear(), T();
+  }), { position: y, total: p, previous: h, next: d, loading: b, listRoute: S, context: {
+    get back() {
+      return { label: typeof r.backLabel == "function" ? r.backLabel() : r.backLabel, to: S.value ?? r.list };
+    },
+    get neighbors() {
+      return y.value === null ? null : { position: y.value, total: p.value, previous: h.value?.to ?? null, next: d.value?.to ?? null };
+    }
+  } };
+}
+export {
+  te as u
+};

package/dist/notifications/InboxPanel.vue.d.ts

@@ -0,0 +1,16 @@
+import type { Inbox } from "./inbox";
+/**
+ * The inbox: what the popover (wide screens) and the sheet (phones) show. Newest first; a tap marks the
+ * notification read and opens its link; "Mark all as read" marks what has been seen; older ones
+ * come with "Show older". Loading, failure and emptiness are the library's own states.
+ */
+type __VLS_Props = {
+    inbox: Inbox;
+    appearance: "popover" | "sheet";
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/notifications/MarkAllRead.vue.d.ts

@@ -0,0 +1,7 @@
+import type { Inbox } from "./inbox";
+/** "Mark all as read": what has been seen, up to the newest id the inbox shows. Off while nothing is unread. */
+type __VLS_Props = {
+    inbox: Inbox;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/notifications/NotificationBell.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/notifications/SettingsLink.vue.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: () => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/notifications/context.d.ts

@@ -0,0 +1,20 @@
+import type { ShallowRef } from "vue";
+import type { IconName } from "../icon";
+import type { Hue } from "../state";
+import type { Inbox } from "./inbox";
+/** How a category of notification is drawn in the inbox: the icon of its row and the colour behind it. */
+export interface NotificationCategoryLook {
+    /** Default: the bell. */
+    icon?: IconName;
+    /** One of the category hues; default neutral. */
+    hue?: Hue;
+}
+/** What the bell and the inbox read from the feature that installed them. */
+export interface NotificationsContext {
+    /** The signed-in session's inbox; null while nobody is signed in (it is made and ended with the session). */
+    readonly inbox: ShallowRef<Inbox | null>;
+    readonly categories: Readonly<Record<string, NotificationCategoryLook>>;
+    /** Whether the settings page is installed: the inbox shows its gear. */
+    readonly settings: boolean;
+}
+export declare const notificationsContextKey: import("vue").InjectionKey<NotificationsContext>, useNotificationsContext: () => NotificationsContext;

package/dist/notifications/deadletters/DeadLetters.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/notifications/deadletters/access.d.ts

@@ -0,0 +1,3 @@
+import type { Permission } from "../../platform";
+export declare const VIEW_DEAD_LETTERS: Permission;
+export declare const RETRY_DEAD_LETTERS: Permission;

package/dist/notifications/deadletters/list.d.ts

@@ -0,0 +1,3 @@
+import type { HttpClient } from "../../client";
+/** The dead letters of every consumer of the application's event queue, as go-core's `GET /v1/events/dead-letters` pages them (newest first; only the consumer narrows it). */
+export declare function deadLetterList(http: HttpClient): import("../../collection").CollectionDefinition<import("..").DeadLetterRow, never, "consumer", never>;

package/dist/notifications/deadletters/routes.d.ts

@@ -0,0 +1,13 @@
+import type { RouteRecordRaw } from "vue-router";
+/**
+ * The route of the dead-letters page (`/events/dead-letters`, name `events.deadletters`), for whoever holds
+ * `events.deadletter:view`: a typed target for links and the record `notificationsFeature` installs.
+ */
+export interface DeadLettersRoutes {
+    /** The records `notificationsFeature` installs. */
+    readonly records: readonly RouteRecordRaw[];
+    readonly index: {
+        readonly name: "events.deadletters";
+    };
+}
+export declare const deadLettersRoutes: DeadLettersRoutes;

package/dist/notifications/feature.d.ts

@@ -0,0 +1,31 @@
+import { type Feature } from "../app";
+import type { Destination } from "../router";
+import { type NotificationCategoryLook } from "./context";
+export interface NotificationsFeatureOptions {
+    /** How each category the application declared in go-core is drawn: the icon of its rows and the colour behind it. A category without an entry gets the bell on a neutral tile. */
+    categories?: Readonly<Record<string, NotificationCategoryLook>>;
+    /**
+     * The dead-letters page (`/events/dead-letters`, route `events.deadletters`) for whoever holds `events.deadletter:view`:
+     * the events a consumer of the queue gave up on, with retry behind `events.deadletter:retry`. `destination` is the node of
+     * the server's menu that opens it; without one the application binds the page itself. `false` leaves the page out.
+     * Default: the page, with no menu binding.
+     */
+    deadLetters?: {
+        destination?: Destination;
+    } | false;
+    /**
+     * The person's own notification settings (`/profile/notifications`, route `notifications.settings`): the categories they get by e-mail
+     * and their quiet hours, reached from the account menu ("Notification settings") and from a gear in the inbox. Needs no permission, only a
+     * session. The names of the categories are the application's texts `notifications.categories.<code>.label` (and `.description`), the code
+     * split at its dots; a category without a text is shown by its code. `false` leaves the page, the menu entry and the gear out. Default true.
+     */
+    settings?: boolean;
+}
+/**
+ * The in-app notifications of go-core's notification module, one feature to install: the bell with the
+ * unread count in the shell's `headerActions`, the inbox it opens (a popover on wide screens, a bottom sheet on
+ * phones), and the live stream behind both, which follows the session. Needs a shell with a `headerActions` place.
+ *
+ *   createApplication({ platform, shell: backofficeShell(), features: [identityFeature(), notificationsFeature({ categories: { "tickets.assigned": { icon: "user3Line", hue: "blue" } }, deadLetters: { destination: "events.deadletters" } })] })
+ */
+export declare function notificationsFeature(options?: NotificationsFeatureOptions): Feature;