@wssto2/vue-core 0.9.4 → 0.11.0

package/dist/i18n/plural.d.ts

@@ -0,0 +1,23 @@
+import type { PluralizationRule } from "vue-i18n";
+/**
+ * Plural rules for the Slavic locales the library ships, ready for `pluralRules` of `createApplication`
+ * (or of `createI18n`). vue-i18n picks the form of `t("key", { count })` by the index a rule returns
+ * for the number of forms the message has, so the message is written in the order of its layout:
+ *
+ * | forms | layout                            | hr, bs, sr-Latn                  | sl                            |
+ * |-------|-----------------------------------|----------------------------------|-------------------------------|
+ * | 2     | one \| other                      | 1, 21, 101 … / the rest          | 1, 101 … / the rest           |
+ * | 3     | none \| one \| other              | 0 / 1, 21 … / the rest           | the same                      |
+ * | 4     | none \| one \| few \| other       | + 2-4, 22-24 … (not 12-14)       | + 2-4, 102-104 … (two is few) |
+ * | 5     | none \| one \| two \| few \| other | as 4 (no dual: two is few)       | + 2, 102 … / 3-4, 103 …       |
+ *
+ *   "{count} osoba | {count} osoba | {count} osobe | {count} osoba"   // hr: none | one | few | other
+ *   createApplication({ pluralRules: slavicPluralRules, … })
+ */
+export type PluralCategory = "none" | "one" | "two" | "few" | "other";
+/** Croatian, Bosnian and Serbian: one (1, 21, 101 …), few (2-4, 22-24 …), other (5-20, 25 …; 111-114 …). */
+export declare const slavicPluralRule: PluralizationRule;
+/** Slovenian: one (1, 101 …), two (2, 102 …), few (3-4, 103-104 …), other (5-100 …); without a dual form two is few. */
+export declare const slovenianPluralRule: PluralizationRule;
+/** The rules of every locale the library ships a Slavic language for, by vue-i18n locale code. */
+export declare const slavicPluralRules: Readonly<Record<"hr" | "bs" | "sr-Latn" | "sl", PluralizationRule>>;

package/dist/i18n/serverMessages.d.ts

@@ -0,0 +1,16 @@
+import type { FormFailureKind } from "../form";
+/**
+ * What a form needs to speak any go-core refusal, in the app's language (an app's `errors.<reason>` first, then
+ * `core.errors.<reason>`): the reason of a field (`identity.email.taken`) becomes a sentence (`describeFieldError`); a refusal of
+ * the whole action (a veto of the application's hook, a lock) says its reason instead of the generic line (`failureMessage`); a
+ * time a lock ends (`locked_until`) reads as a time of day. Spread into `useForm` / `useCommand`, or call `failureMessage(kind, error)`
+ * inside an `failureMessage` of your own to put the application's refusals first; `sentence` is the same for a toast or a line of your own:
+ *
+ *   const messages = useServerMessages();
+ *   useForm({ ...messages, failureMessage: (kind, error) => myRefusal(error) ?? messages.failureMessage(kind, error), defaults, validator });
+ */
+export declare function useServerMessages(): {
+    sentence: (error: unknown, fallback?: string) => string;
+    describeFieldError: (message: string) => string;
+    failureMessage: (kind: FormFailureKind, error: unknown) => string | undefined;
+};

package/dist/identity/embed.d.ts

@@ -0,0 +1,39 @@
+import { type HttpClient } from "../client";
+import { type SessionAdapter, type SessionUser, type UserParser } from "../platform";
+/** Where an embed session keeps its token: the part of `Storage` it uses. */
+export type EmbedStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+export interface EmbedSessionOptions {
+    /** Default `sessionStorage`: tab-scoped and same-origin, which a cross-origin iframe's browser (Safari's tracking prevention) still allows where cookies and `localStorage` are blocked. */
+    storage?: EmbedStorage;
+    /** The storage key of the token. Default `embed_access_token`. */
+    tokenKey?: string;
+    /** The storage key of the moment the token ends (an ISO date). Default `embed_expires_at`. */
+    expiresKey?: string;
+}
+/**
+ * A session an iframe's host page hands over as a bearer token (the cookies of an embedded page are blocked): kept in
+ * the tab's storage, sent as `Authorization: Bearer`, and not renewable, as there is no refresh token. The page that
+ * receives the token calls `start`; everything else is wired by `identityPlatform({ embed })`.
+ */
+export interface EmbedSession {
+    /** Keeps the token the server handed out, and the moment it ends. */
+    start(token: string, expiresAt: string): void;
+    /** Forgets the token: the page goes back to the cookie session, if there is one. */
+    end(): void;
+    /** The token, or null when there is none (or the storage is not available). */
+    token(): string | null;
+    /** Whether an embed token is held; the session then cannot be renewed. */
+    active(): boolean;
+    /** Whether the held token has run out (a missing end counts as run out). */
+    expired(): boolean;
+}
+/** The embed session over the tab's storage; a storage that throws (blocked, private mode) reads as no session and keeps nothing. */
+export declare function embedSession(options?: EmbedSessionOptions): EmbedSession;
+/** The headers every request carries for an embed session: the bearer token, or none. */
+export declare const embedHeaders: (embed: EmbedSession) => () => Record<string, string>;
+/**
+ * The session adapter while an embed token is held: read with the bearer token (`/auth/me`, no refresh), none when the
+ * token ran out or is refused (and then forgotten); sign-out ends the server's session and forgets the token. Without a
+ * token it is the cookie session `inner`.
+ */
+export declare function embeddedSessionAdapter<U extends SessionUser>(inner: SessionAdapter<U>, http: HttpClient, parseUser: UserParser<U>, embed: EmbedSession): SessionAdapter<U>;

package/dist/identity/index.d.ts

@@ -5,9 +5,30 @@ export { identityFeature } from "./feature";
 export type { IdentityFeatureOptions } from "./feature";
 export { identityPlatform, identitySessionAdapter } from "./session";
 export type { IdentityPlatformOptions } from "./session";
+export { embedHeaders, embedSession } from "./embed";
+export type { EmbedSession, EmbedSessionOptions, EmbedStorage } from "./embed";
 export { usersFeature } from "./users/feature";
 export type { UsersFeatureOptions } from "./users/feature";
-export type { PersonSection } from "./users/personSections";
+export type { BuiltInPersonSection, PersonSection } from "./users/personSections";
+export type { UsersReplace, NewUserDialogHandle, NewUserDialogEmits, DeactivateDialogProps, DeactivateDialogHandle, DeactivateDialogEmits } from "./users/replace";
+export type { ActivityRecord, ChangeDetail, ChangeWords, ChangeWordsFn, Translate } from "./users/words";
+export type { OpenChangeRow } from "./users/ext";
+export { PERSON, personActionsKey, usePersonActions, usePersonSessions } from "./users/person";
+export type { PersonActions } from "./users/person";
+export { useUsersContext } from "./users/context";
+export type { UsersContext } from "./users/context";
+export { useUserDialogs } from "./users/dialogs";
+export { USER_VIEWS, userList } from "./users/list";
+export type { UsersCollection } from "./users/list";
+export { default as NewUserDialog } from "./users/NewUserDialog.vue";
+export { default as DeactivateDialog } from "./users/DeactivateDialog.vue";
+export { statusTone } from "./users/status";
+export { default as PageBar } from "./shared/PageBar.vue";
+export { default as SectionIntro } from "./shared/SectionIntro.vue";
+export { default as SessionList } from "./shared/SessionList.vue";
+export { default as SignInList } from "./shared/SignInList.vue";
+export { default as SignInTable } from "./shared/SignInTable.vue";
+export { default as ChangeFeed } from "./shared/ChangeFeed.vue";
 export type { ProfilePanel, ProfileSection } from "./profile/profileSections";
 export { profileRoutes } from "./profile/routes";
 export { usersRoutes } from "./users/routes";

package/dist/identity/index.js

@@ -1,23 +1,42 @@
-import { _ as t, k as a, l as o, i as n, m as i, d as r, n as u, o as c, q as d, r as A, t as p, s as R, v as f, w as l, x as m, g as y } from "../index-CdtofdcJ.js";
-import { _ as v } from "../ActionRow.vue_vue_type_script_setup_true_lang-Cg1lhpcA.js";
-import { s as I } from "../routes-Beyr5NQo.js";
+import { m as a, v as t, w as n, P as o, l as i, j as r, _ as u, t as c, k as d, U as S, x as g, y as A, z as l, A as I, i as p, B as R, g as m, C as y, D as U, r as f, E as P, F as v, G as x, p as D, H as E, I as F, s as b, e as w, h as B, b as C, f as L, J as T, K as _, c as h } from "../index-Cq9TuOqH.js";
+import { a as H, _ as K } from "../ActionRow.vue_vue_type_script_setup_true_lang-DybAIOHS.js";
+import { s as O } from "../routes-Beyr5NQo.js";
 export {
-  v as ActionRow,
-  t as SignInAsButton,
-  a as identityFeature,
-  o as identityPlatform,
-  n as identityRoutes,
-  i as identitySessionAdapter,
-  r as isSessionEnded,
-  u as lockedUntil,
-  c as parseIdentityUser,
-  d as profileRoutes,
-  A as returnToOwnAccount,
-  p as serviceAccountsFeature,
-  R as serviceAccountsRoutes,
-  I as serviceaccountRoutes,
-  f as signIn,
-  l as signInAs,
-  m as usersFeature,
-  y as usersRoutes
+  H as ActionRow,
+  a as ChangeFeed,
+  t as DeactivateDialog,
+  n as NewUserDialog,
+  o as PERSON,
+  i as PageBar,
+  K as SectionIntro,
+  r as SessionList,
+  u as SignInAsButton,
+  c as SignInList,
+  d as SignInTable,
+  S as USER_VIEWS,
+  g as embedHeaders,
+  A as embedSession,
+  l as identityFeature,
+  I as identityPlatform,
+  p as identityRoutes,
+  R as identitySessionAdapter,
+  m as isSessionEnded,
+  y as lockedUntil,
+  U as parseIdentityUser,
+  f as personActionsKey,
+  P as profileRoutes,
+  v as returnToOwnAccount,
+  x as serviceAccountsFeature,
+  D as serviceAccountsRoutes,
+  O as serviceaccountRoutes,
+  E as signIn,
+  F as signInAs,
+  b as statusTone,
+  w as usePersonActions,
+  B as usePersonSessions,
+  C as useUserDialogs,
+  L as useUsersContext,
+  T as userList,
+  _ as usersFeature,
+  h as usersRoutes
 };

package/dist/identity/session.d.ts

@@ -1,6 +1,7 @@
 import { type HttpClient } from "../client";
 import { type PlatformOptions, type SessionAdapter, type SessionUser, type UserParser } from "../platform";
 import type { BootstrapConfig } from "../platform";
+import { type EmbedSession } from "./embed";
 import { type IdentityUser } from "./user";
 /**
  * The session over go-core's identity routes: `GET /v1/auth/me`; when that says 401 (the access token ran
@@ -8,13 +9,20 @@ import { type IdentityUser } from "./user";
  */
 export declare function identitySessionAdapter<U extends SessionUser>(http: HttpClient, parseUser: UserParser<U>): SessionAdapter<U>;
 /** What `createPlatform` is given to run on go-core's identity module. */
-export type IdentityPlatformOptions<U extends SessionUser> = Required<Pick<PlatformOptions<U, BootstrapConfig>, "session" | "renewSession">> & Pick<PlatformOptions<U, BootstrapConfig>, "renewable">;
+export type IdentityPlatformOptions<U extends SessionUser> = Required<Pick<PlatformOptions<U, BootstrapConfig>, "session" | "renewSession">> & Pick<PlatformOptions<U, BootstrapConfig>, "renewable" | "headers" | "onSessionExpired">;
 /** What `identityPlatform` takes. */
 export interface IdentityPlatformInput<U extends SessionUser> {
     /** The application's own user projection; see `identityPlatform`. */
     parseUser?: UserParser<U>;
     /** False while the session has no refresh token (an embed bearer session): nothing renews it, a 401 ends it. See `PlatformOptions.renewable`. */
     renewable?: () => boolean;
+    /**
+     * A session handed over as a bearer token (an iframe whose cookies are blocked): while one is held the requests carry it,
+     * the session is read with it and cannot be renewed, a refused or run-out token is forgotten, and signing out forgets
+     * it. It sets `headers` and `onSessionExpired` of the platform, so spread `identityPlatform()` first and, when you set
+     * either yourself, keep the embed's part (`embed.end()` on expiry, `embedHeaders(embed)`).
+     */
+    embed?: EmbedSession;
 }
 /**
  * The platform options that wire the session to go-core's identity routes: reading it (`/auth/me`, with one

package/dist/identity/shared/ChangeFeed.vue.d.ts

@@ -1,11 +1,14 @@
-import type { ChangeRow } from "../../modules/identity/entities";
+import type { OpenChangeRow } from "../users/ext";
+import type { ChangeWordsFn } from "../users/words";
 /**
  * What was changed on a person's account, newest first, one sentence per change ("Details changed", "Password changed"),
  * with who did it (by the name the row carries, "somebody else" when the person is gone; nothing when it was the person themselves), what changed from what to what, and when. An action or a
- * field this version does not know reads as a generic one, never as its key; a password is never shown.
+ * field this version does not know reads as a generic one, never as its key; a password is never shown. `words` is the
+ * application's own wording (`usersFeature({ changeWords })`): its sentence replaces the library's, its details follow them.
  */
 type __VLS_Props = {
-    rows: readonly ChangeRow[];
+    rows: readonly OpenChangeRow[];
+    words?: ChangeWordsFn;
 };
 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/identity/users/context.d.ts

@@ -1,5 +1,8 @@
 import type { ProfileSection } from "../profile/profileSections";
 import { type Permission } from "../../platform";
+import type { UsersCollection } from "./list";
+import type { UsersReplace } from "./replace";
+import type { ActivityRecord, ChangeWordsFn } from "./words";
 /** What the screens of `usersFeature` need from the feature that installed them. */
 export interface UsersContext {
     /** The permission that shows "Sign in as" on a person's record; false leaves it out. */
@@ -8,5 +11,13 @@ export interface UsersContext {
     readonly activityAreas: Readonly<Record<string, string>>;
     /** The panels the application adds to "My profile". */
     readonly profileSections: readonly ProfileSection[];
+    /** The screens the application swapped for its own (`useUserDialogs()` resolves the dialogs). */
+    readonly replace: UsersReplace;
+    /** The application's definition of the list, used by the list page and the record's previous / next; without it `userList`. */
+    readonly collection: UsersCollection | undefined;
+    /** The records the Activity section names and links, by the server's `record_type`. */
+    readonly activityRecords: Readonly<Record<string, ActivityRecord>>;
+    /** The application's wording of a change; without it the library's. */
+    readonly changeWords: ChangeWordsFn | undefined;
 }
 export declare const usersContextKey: import("vue").InjectionKey<UsersContext>, useUsersContext: () => UsersContext;

package/dist/identity/users/dialogs.d.ts

@@ -0,0 +1,10 @@
+import type { Component } from "vue";
+/**
+ * The New user and Deactivate dialogs the screens use: the application's (`usersFeature({ replace })`) or the library's. A
+ * replaced list or record mounts these, so one replacement of a dialog serves every screen. Use them through a template ref
+ * (`NewUserDialogHandle`, `DeactivateDialogHandle`).
+ */
+export declare function useUserDialogs(): {
+    newUser: Component;
+    deactivate: Component;
+};

package/dist/identity/users/ext.d.ts

@@ -0,0 +1,8 @@
+import type { ChangeRow } from "../../modules/identity/entities";
+/**
+ * A change as the server's change log writes it: go-core's `ChangeRow` (with its `ext`), except that the `action` can be one
+ * go-core does not know (a role granted, a binding changed), which the application words with `changeWords`.
+ */
+export type OpenChangeRow = Omit<ChangeRow, "action"> & {
+    action: ChangeRow["action"] | (string & {});
+};

package/dist/identity/users/feature.d.ts

@@ -2,7 +2,10 @@ import { type Feature } from "../../app";
 import type { Permission } from "../../platform";
 import type { Destination } from "../../router";
 import type { ProfileSection } from "../profile/profileSections";
+import type { UsersCollection } from "./list";
 import { type PersonSection } from "./personSections";
+import type { UsersReplace } from "./replace";
+import type { ActivityRecord, ChangeWordsFn } from "./words";
 export interface UsersFeatureOptions {
     /** The users list and a person's record (`/users`), for whoever holds `iam.user:view`. Default true. */
     people?: boolean;
@@ -12,12 +15,30 @@ export interface UsersFeatureOptions {
     signInAs?: Permission | false;
     /** Names of the application's areas in a person's Activity: the area key the audit records (`crm`) and the i18n key of its name. `all`, `identity` and `other` are the library's. An area without a key reads as "Other". */
     activityAreas?: Readonly<Record<string, string>>;
-    /** Sections the application adds to a person's record after the feature's own (their roles); each is a child route `users.record.<path>`. */
+    /** Sections the application adds to a person's record (their roles), at the end or, with `after`, behind a built-in one; each is a child route `users.record.<path>`. */
     sections?: readonly PersonSection[];
     /** Panels the application adds to "My profile" (mobile phone, dealer and location, preferences), each placed after or before a built-in panel. */
     profileSections?: readonly ProfileSection[];
     /** The destination of the backend's menu that opens the users list. Without it the application binds the list itself. */
     destination?: Destination;
+    /** The base path of the list; a record is `<path>/:id`. Default `/users`. The route names stay (`users.index`, `users.record`), so links by name follow it. */
+    path?: `/${string}`;
+    /** Whole screens the application swaps for its own, each keeping the contract documented on `UsersReplace`: the list, the details section, the New user and the Deactivate dialogs. */
+    replace?: UsersReplace;
+    /**
+     * The one definition of the people list, for the list page and for the previous / next of a person's record, so both ask the
+     * server the same question. Default `userList` (the library's). An application whose list filters people by more than the
+     * library knows (a dealer, a role) passes its own collection: the very definition its `replace.list` page calls `useCollection`
+     * on, since the record replays the state that page wrote into the link. A definition, not a factory: the application builds it
+     * once, with its own client; the library's default is built from the platform's.
+     *
+     *   usersFeature({ collection: peopleList, replace: { list: PeopleList } })   // peopleList = defineCollection({ id: "identity.users", …, query: { filters: ["dealer_id", "role"] } })
+     */
+    collection?: UsersCollection;
+    /** What the Activity section calls and links the records the application knows, by the server's `record_type`; an unknown type reads as the type itself. */
+    activityRecords?: Readonly<Record<string, ActivityRecord>>;
+    /** The application's wording for a change (sentence and details, with links), asked for every row of the Changes section with its `ext`; the library words what it returns nothing for. */
+    changeWords?: ChangeWordsFn;
 }
 /**
  * The screens of go-core's users and profile routes, one feature to install:

package/dist/identity/users/list.d.ts

@@ -1,8 +1,19 @@
 import type { HttpClient } from "../../client";
+import { type CollectionDefinition } from "../../collection";
 /** The views of the list, as go-core's `GET /v1/iam/users` knows them. */
 export declare const USER_VIEWS: readonly ["active", "locked", "inactive", "all"];
+/**
+ * The definition of the people list that `usersFeature({ collection })` takes: any collection of people, with the sorts and
+ * filters the application's server accepts. Its rows must carry what the screens read of a `UserRow`.
+ */
+export type UsersCollection = CollectionDefinition<any, any, any, any>;
 /**
  * The list of people, one definition for the list page and for the previous / next of a person's record, so both ask
  * the server the same question. The sorts and views are the ones go-core accepts.
  */
-export declare function userList(http: HttpClient): import("../../collection").CollectionDefinition<import("..").UserRow, "name" | "email" | "login" | "created_at", never, "inactive" | "all" | "locked" | "active">;
+export declare function userList(http: HttpClient): CollectionDefinition<import("..").UserRow, "name" | "email" | "login" | "created_at", "last_sign_in", "inactive" | "all" | "locked" | "active", Readonly<Record<string, unknown>>>;
+/**
+ * The definition the users screens ask the list with: the application's (`usersFeature({ collection })`) or `userList`. The list
+ * page and the previous / next of a record both call it, so they ask the server the same question.
+ */
+export declare function useUserList(): ReturnType<typeof userList>;

package/dist/identity/users/personSections.d.ts

@@ -1,16 +1,22 @@
 import { type Component } from "vue";
 import type { RouteRecordRaw } from "vue-router";
-import type { UserDetail } from "../../modules/identity/entities";
 import type { AccessRequirement, RouteSection } from "../../router";
+import type { UserDetail } from "../../modules/identity/entities";
+/** The paths of the sections the feature's own record has, in order; what `PersonSection.after` can name. */
+export declare const PERSON_SECTIONS: readonly ["general", "signin", "sessions", "signins", "changes", "activity"];
+export type BuiltInPersonSection = (typeof PERSON_SECTIONS)[number];
 /**
- * A section the application adds to a person's record (their roles, say), listed after the feature's own. The component
- * gets what `props` makes of the loaded person; `meta` is the section's route meta (its label, icon and `access`).
+ * A section the application adds to a person's record (their roles, say). The component gets what `props` makes of the loaded
+ * person; `meta` is the section's route meta (its label, icon and `access`). It is listed after the feature's own, or, with
+ * `after`, right behind one of them and in that one's group (`meta.section.groupKey` is then the group's):
  *
- *   usersFeature({ sections: [{ path: "roles", component: PersonAccess, props: (p) => ({ subject: { kind: "user", id: p.id }, name: p.name }), meta: personRolesSection }] })
+ *   usersFeature({ sections: [{ path: "roles", after: "signin", component: PersonAccess, props: (p) => ({ subject: { kind: "user", id: p.id }, name: p.name }), meta: personRolesSection }] })
  */
 export interface PersonSection {
     /** The child route's path under `/users/:id/` and its name suffix (`users.record.<path>`): one lowercase word. */
     readonly path: string;
+    /** Places the section right after this built-in one, in its group (Sign-in is in "Access", so a section after it is too). Several after the same one keep their order. Without it: at the end. */
+    readonly after?: BuiltInPersonSection;
     readonly component: Component;
     readonly props?: (person: UserDetail) => Record<string, unknown>;
     readonly meta: {
@@ -18,5 +24,8 @@ export interface PersonSection {
         readonly section: RouteSection;
     };
 }
-/** The child route of the record for an extra section. */
-export declare function personSectionRoute(section: PersonSection): RouteRecordRaw;
+/**
+ * The record's children with the application's sections in place: behind the built-in one they name, in its group, or at the
+ * end. A name that is not a built-in section is a start-up error that lists the valid ones.
+ */
+export declare function withPersonSections(children: readonly RouteRecordRaw[], sections: readonly PersonSection[]): RouteRecordRaw[];

package/dist/identity/users/replace.d.ts

@@ -0,0 +1,45 @@
+import type { Component } from "vue";
+import type { UserDetail } from "../../modules/identity/entities";
+/**
+ * Whole screens of `usersFeature` an application swaps for its own, with the contract each one keeps. A replacement is
+ * mounted where the built-in was, with the same props and events, and finds the same context: `usePlatform()`, the record
+ * (`useRouteResourceContext(PERSON)`), the actions (`usePersonActions()`), `useUsersContext()`, the collection (`userList`),
+ * and the shared pieces exported beside them.
+ */
+export interface UsersReplace {
+    /** The users list, the page of `users.index`. No props. Open the New user dialog with `useUserDialogs().newUser`. */
+    readonly list?: Component;
+    /** The "Basic details" section of a person's record (`users.record.general`). No props; reads the person with `useRouteResourceContext(PERSON)`, and its save chrome and rows are its own. */
+    readonly general?: Component;
+    /** The New user dialog: no props, emits `created` with the new person, exposes `create()` (a `NewUserDialogHandle`). */
+    readonly newUser?: Component;
+    /** The Deactivate dialog: props `DeactivateDialogProps`, emits `done` after it deactivated, exposes `open()` (a `DeactivateDialogHandle`). */
+    readonly deactivate?: Component;
+}
+/** What the users list and any other screen call on the New user dialog (`replace.newUser`), through a template ref. */
+export interface NewUserDialogHandle {
+    /** Opens the dialog on an empty form. */
+    create(): void;
+}
+/** The events of the New user dialog. */
+export interface NewUserDialogEmits {
+    /** The person was created; the list opens their record. */
+    created: [user: UserDetail];
+}
+/** The props of the Deactivate dialog (`replace.deactivate`). */
+export interface DeactivateDialogProps {
+    readonly id: number;
+    readonly name: string;
+    /** How many sessions the person has now; null while they are being counted. */
+    readonly sessionCount: number | null;
+}
+/** What the record page calls on the Deactivate dialog. */
+export interface DeactivateDialogHandle {
+    /** Opens the dialog. */
+    open(): void;
+}
+/** The events of the Deactivate dialog. */
+export interface DeactivateDialogEmits {
+    /** The person was deactivated; the record reloads. */
+    done: [];
+}

package/dist/identity/users/words.d.ts

@@ -0,0 +1,28 @@
+import type { RouteLocationRaw } from "vue-router";
+import type { OpenChangeRow } from "./ext";
+/** Where the Activity section sends a record the application knows: its name (an i18n key) and, when it has a page, the link. */
+export interface ActivityRecord {
+    /** The i18n key of the kind of record ("Lead"); shown instead of the server's `record_type`. */
+    readonly labelKey: string;
+    /** The page of the record with this id; without it the row names the record and does not link. */
+    readonly to?: (id: number) => RouteLocationRaw;
+}
+/** A piece of a change's details: plain text, or text that links (a hand-over recipient, a binding). */
+export type ChangeDetail = string | {
+    readonly text: string;
+    readonly to: RouteLocationRaw;
+};
+/** What the application says about one change in the Changes section; every part left out keeps the library's wording. */
+export interface ChangeWords {
+    /** The sentence ("Role granted"), already translated. */
+    readonly sentence?: string;
+    /** Details after the library's own ("Dealer: A to B"). */
+    readonly details?: readonly ChangeDetail[];
+}
+/** `t` as `useI18n()` gives it. */
+export type Translate = (key: string, named?: Record<string, unknown>) => string;
+/**
+ * The application's wording for a change: asked for every row (with its `ext`, as the server's change log wrote it); return
+ * `undefined` for a row the library already words well. Used by `usersFeature({ changeWords })`.
+ */
+export type ChangeWordsFn = (row: OpenChangeRow, t: Translate) => ChangeWords | undefined;

package/dist/incidents/api.d.ts

@@ -4,7 +4,7 @@ import type { CommentRequest, ReportInput, UpdateRequest } from "../modules/inci
 export type IncidentSort = "title" | "last_seen_at";
 export type IncidentFilter = "created_at" | "status" | "severity" | "source";
 /** The incident list: last seen first. Made over the platform's client, in `setup`; the list and the record's previous / next share its id. */
-export declare function incidentList(http: HttpClient): import("../collection").CollectionDefinition<Incident, IncidentSort, IncidentFilter, string>;
+export declare function incidentList(http: HttpClient): import("../collection").CollectionDefinition<Incident, IncidentSort, IncidentFilter, string, Readonly<Record<string, unknown>>>;
 /** An incident's page: the incident, the user reports behind it and its comments, from one read. */
 export interface IncidentDetail {
     readonly incident: Incident;

package/dist/incidents/index.js

@@ -1,4 +1,4 @@
-import { h as t, j as i, k as r, l as n, i as a } from "../index-Dm-sdJJr.js";
+import { h as t, j as i, k as r, l as n, i as a } from "../index-kEHY7hcG.js";
 export {
   t as MAX_REPORTS_PER_SESSION,
   i as clientErrorReporter,

package/dist/{index-Dz0LkLM8.js → index-ClJeyW3F.js}

@@ -12,10 +12,10 @@ import { _ as ke } from "./Sheet.vue_vue_type_script_setup_true_lang-B91aRD_y.js
 import { _ as Se } from "./Popover.vue_vue_type_script_setup_true_lang-C20Hf3Hl.js";
 import { _ as J } from "./HeaderAction.vue_vue_type_script_setup_true_lang-Da59TLBh.js";
 import { useRouter as Te } from "vue-router";
-import { _ as K } from "./Button.vue_vue_type_script_setup_true_lang-Dp7OB-eF.js";
+import { _ as K } from "./Button.vue_vue_type_script_setup_true_lang-C74hcb0N.js";
 import { u as Ee } from "./format-D8KUBmbS.js";
 import { _ as Pe } from "./Icon.vue_vue_type_script_lang-BhhsFYwp.js";
-import { _ as Ce } from "./AsyncSection.vue_vue_type_script_setup_true_lang-BdeOKqz_.js";
+import { _ as Ce } from "./AsyncSection.vue_vue_type_script_setup_true_lang-DGzQ-Snp.js";
 const E = {
   list: v("GET", "/v1/notifications"),
   unread: v("GET", "/v1/notifications/unread"),
@@ -135,9 +135,9 @@ function Me(n = ee().http, t = W()) {
   return { state: $(e), hash: $(i), busy: $(a), inspect: c, enable: u, disable: g };
 }
 const Ne = "events.deadletter:view", $t = "events.deadletter:retry", Y = te({
-  index: { name: "events.deadletters", path: "/events/dead-letters", component: () => import("./DeadLetters-Bb5pPlOY.js"), meta: { access: Ne, titleKey: "core.notifications.dead_letters.title" } }
+  index: { name: "events.deadletters", path: "/events/dead-letters", component: () => import("./DeadLetters-DnA7LP1w.js"), meta: { access: Ne, titleKey: "core.notifications.dead_letters.title" } }
 }), j = te({
-  index: { name: "notifications.settings", path: "/profile/notifications", component: () => import("./SettingsPage-DzDC7gD-.js"), meta: { titleKey: "core.notifications.settings.title" } }
+  index: { name: "notifications.settings", path: "/profile/notifications", component: () => import("./SettingsPage-BXPWATYU.js"), meta: { titleKey: "core.notifications.settings.title" } }
 }), Oe = /* @__PURE__ */ q({
   __name: "SettingsMenuItem",
   setup(n) {