@wssto2/vue-core 0.2.0 → 0.4.0

package/dist/ViewTabs.vue_vue_type_script_setup_true_lang-BJIoZAlH.js

@@ -0,0 +1,28 @@
+import { defineComponent as u, useModel as m, computed as d, openBlock as r, createBlock as p, unref as c, mergeModels as i } from "vue";
+import { _ as b } from "./Tabs.vue_vue_type_script_setup_true_lang-CcMcE38r.js";
+const _ = /* @__PURE__ */ u({
+  __name: "ViewTabs",
+  props: /* @__PURE__ */ i({
+    views: {},
+    counts: {},
+    labelOf: { type: Function },
+    label: {}
+  }, {
+    modelValue: { required: !0 },
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(a) {
+    const e = a, t = m(a, "modelValue"), n = d(() => e.views.map((l) => ({ value: l, label: e.labelOf(l), badge: e.counts?.find((o) => o.key === l)?.count })));
+    return (l, o) => (r(), p(c(b), {
+      modelValue: t.value,
+      "onUpdate:modelValue": o[0] || (o[0] = (s) => t.value = s),
+      tabs: n.value,
+      presentation: "scope",
+      label: e.label
+    }, null, 8, ["modelValue", "tabs", "label"]));
+  }
+});
+export {
+  _
+};

package/dist/access/AddRoleDialog.vue.d.ts

@@ -0,0 +1,19 @@
+import type { Binding, SubjectRef } from "../modules/access/entities";
+/**
+ * *Add role*: where first (a level of the hierarchy and the place, from what the server says this person may be given and the actor may give;
+ * an application with one level asks nothing here), then the role, from the ones the actor may give there (delegation already applied). What the
+ * chosen role reaches is the role's own and is only shown: it changes in Roles, not here.
+ */
+type __VLS_Props = {
+    subject: SubjectRef;
+    subjectLabel: string;
+};
+declare function present(): Promise<void>;
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    present: typeof present;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    added: (binding: Binding) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAdded?: ((binding: Binding) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/access/BindingRow.vue.d.ts

@@ -0,0 +1,19 @@
+import type { Binding } from "../modules/access/entities";
+/**
+ * One role a person holds and where it applies, read-only: the role's name, its kind under it, the place on the right. The
+ * access panel puts *Remove* in the trailing slot; a profile page shows it as it is.
+ */
+type __VLS_Props = {
+    binding: Pick<Binding, "role" | "scope">;
+};
+type __VLS_Slots = {
+    trailing?: () => unknown;
+};
+declare const __VLS_component: 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>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/access/EffectiveAccess.vue.d.ts

@@ -0,0 +1,12 @@
+import type { EffectivePermission } from "../modules/access/entities";
+/**
+ * *What {name} can do*: the effective permissions by module and screen, worked out from the roles; nothing here edits. Each screen says
+ * which actions are held, which roles give them and how wide (whose records, which places); *Why* opens the reason for every action.
+ * A permission switched off for the tenant is marked. On a phone the modules beyond the first three sit behind *All n modules*.
+ */
+type __VLS_Props = {
+    effective: readonly EffectivePermission[];
+    name: string;
+};
+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/access/NewRolePage.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/access/PermissionTree.vue.d.ts

@@ -0,0 +1,13 @@
+import { type Grants } from "./catalogue";
+/**
+ * The permissions of a role as the editor shows them: the catalogue's modules (a list on the left, a tab bar on phones)
+ * with what the role holds of each, then each screen as a group of switches. Switching a permission on switches on what it
+ * needs, off what needs it; where a screen's records have an owner the group opens with *whose* (own, location's, all), held
+ * once per record type. `grants` is edited in place; `readonly` shows the role without letting it change.
+ */
+type __VLS_Props = {
+    grants: Grants;
+    readonly: boolean;
+};
+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/access/PersonAccess.vue.d.ts

@@ -0,0 +1,21 @@
+import type { SubjectRef } from "../modules/access/entities";
+/**
+ * A person's access: their roles, each with where it applies, *Add role* and removal (both offered only when the server says the actor may
+ * manage them), then *What {name} can do*, the effective permissions with their reasons. Put it on the person's record, as a section
+ * (`<PersonAccess :subject="{ kind: 'user', id }" :name="person.name" />`); `subjectLabel` says who a role is added for under the dialog's title.
+ */
+type __VLS_Props = {
+    subject: SubjectRef;
+    /** The person's name, for "What Ana can do". */
+    name: string;
+    /** Under the add dialog's title; by default the name. */
+    subjectLabel?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    reload: () => Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    loaded: (bindings: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onLoaded?: ((bindings: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/access/ReplaceRoleDialog.vue.d.ts

@@ -0,0 +1,17 @@
+import type { Role, RoleSummary } from "../modules/access/entities";
+/**
+ * *Replace*: every holder of a custom role gets a predefined role at the same place instead. It goes through the same rules as
+ * giving a role, so it can be refused (you cannot give more than you hold); either every holder moves or none does.
+ */
+type __VLS_Props = {
+    role: Role;
+    others: readonly RoleSummary[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    present: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    replaced: (rebound: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onReplaced?: ((rebound: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/access/RoleCompareDialog.vue.d.ts

@@ -0,0 +1,14 @@
+import type { Role, RoleSummary } from "../modules/access/entities";
+/**
+ * *Compare with a predefined role*: what a custom role holds that the other does not, what it lacks, and where the whose
+ * differs. The way to see how far a copy has drifted before replacing it.
+ */
+type __VLS_Props = {
+    role: Role;
+    others: readonly RoleSummary[];
+};
+declare function present(): void;
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    present: typeof present;
+}, {}, {}, {}, 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/access/RoleEditor.vue.d.ts

@@ -0,0 +1,28 @@
+import type { Role } from "../modules/access/entities";
+import { type Grants } from "./catalogue";
+/**
+ * A role, read or edited: its name and description, then the permission tree. A custom role edits with Save and Cancel in the
+ * page chrome; a predefined or computed role only reads (*Copy* is its way to a custom one). `source` prefills a new role from
+ * another (Copy): it is still created as a new role.
+ */
+type __VLS_Props = {
+    /** The saved role; null while creating a new one. */
+    role: Role | null;
+    /** The role a new one is copied from. */
+    source?: Role | null;
+};
+interface Draft {
+    name: string;
+    description: string;
+    grants: Grants;
+}
+declare function save(): Promise<void>;
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    form: import("../form").Form<Draft, Draft>;
+    save: typeof save;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    saved: (role: Role) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSaved?: ((role: Role) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/access/RolePage.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/access/RolesPage.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/access/api.d.ts

@@ -0,0 +1,26 @@
+import type { HttpClient } from "../client";
+import type { BindInput, CreateRoleInput, UpdateRoleInput } from "../modules/access/schemas";
+import type { SubjectRef } from "../modules/access/entities";
+type Options = {
+    readonly signal?: AbortSignal;
+};
+/** go-core's access routes as calls; `data` of each answer already read. */
+export declare function createAccessApi(http: HttpClient): {
+    roles: (options?: Options) => Promise<import(".").RoleSummary[]>;
+    role: (ref: string, options?: Options) => Promise<import(".").Role>;
+    holders: (ref: string, options?: Options) => Promise<import(".").RoleHolder[]>;
+    compare: (ref: string, other: string, options?: Options) => Promise<import(".").RoleComparison>;
+    create: (input: CreateRoleInput) => Promise<import(".").Role>;
+    update: (input: UpdateRoleInput) => Promise<import(".").Role>;
+    remove: (ref: string) => Promise<undefined>;
+    replace: (ref: string, other: string) => Promise<number>;
+    access: (subject: SubjectRef, options?: Options) => Promise<import(".").SubjectAccess>;
+    scopes: (subject: SubjectRef, options?: Options) => Promise<import(".").ScopeOptions>;
+    bindable: (level: string, scopeId: number | null, options?: Options) => Promise<import(".").Role[]>;
+    bind: (subject: SubjectRef, input: Omit<BindInput, "id">) => Promise<import(".").Binding>;
+    unbind: (subject: SubjectRef, bindingId: number) => Promise<undefined>;
+};
+export type AccessApi = ReturnType<typeof createAccessApi>;
+/** The calls, over the platform's client; call it in `setup`. */
+export declare const useAccessApi: () => AccessApi;
+export {};

package/dist/access/catalogue.d.ts

@@ -0,0 +1,64 @@
+import type { AccessQualifier } from "../platform";
+/**
+ * What go-core's catalogue says about one permission: the shape of `authzts`'s `PermissionMeta`, so the
+ * `permissions` object its generator writes (`frontend/generated/permissions.ts`) is the catalogue as it is.
+ */
+export interface PermissionMeta {
+    readonly module: string;
+    /** Empty for a permission of the module itself. */
+    readonly resource: string;
+    readonly verb: string;
+    /** i18n keys; the texts live in the application. */
+    readonly labelKey: string;
+    readonly descriptionKey: string;
+    readonly sensitive: boolean;
+    readonly system: boolean;
+    readonly organizationOnly: boolean;
+    /** The record type the "whose" qualifiers refer to; null when the permission has no owner. */
+    readonly ownable: string | null;
+    readonly unownedIsOwn: boolean;
+    readonly feature: string | null;
+    readonly attributes: readonly string[];
+    readonly requires: readonly string[];
+}
+/** Every permission of the application by identifier (`module.resource:verb`). */
+export type PermissionCatalogue = Readonly<Record<string, PermissionMeta>>;
+/** A permission with its identifier. */
+export interface PermissionEntry extends PermissionMeta {
+    readonly id: string;
+}
+/** The permissions of one screen (a resource of a module). */
+export interface PermissionScreen {
+    /** `module` or `module_resource` (dots turned into underscores): the i18n key of its heading, under `access.resources`. */
+    readonly key: string;
+    readonly permissions: readonly PermissionEntry[];
+}
+/** One tab of the editor: a module's screens. Permissions that run the system are together in the group `system`. */
+export interface PermissionGroup {
+    readonly key: string;
+    readonly screens: readonly PermissionScreen[];
+}
+export declare const SYSTEM_GROUP = "system";
+export declare const groupOf: (meta: Pick<PermissionMeta, "module" | "system">) => string;
+export declare const screenKeyOf: (meta: Pick<PermissionMeta, "module" | "resource">) => string;
+/** The catalogue as the editor shows it: module, then screen, then action (view, create, update, manage, delete, the rest by name). */
+export declare function permissionTree(catalogue: PermissionCatalogue): readonly PermissionGroup[];
+/** Everything `id` needs, transitively (not `id` itself). */
+export declare function requiredClosure(catalogue: PermissionCatalogue, id: string): string[];
+/** Everything that needs `id`, transitively (not `id` itself). */
+export declare function dependantsClosure(catalogue: PermissionCatalogue, id: string): string[];
+/** What a role holds: each permission with whose records it reaches (`all` for a permission that has no owner). */
+export type Grants = Record<string, AccessQualifier>;
+/** The whose the role holds of a record type: its view permission's, else any granted one's; null when it holds none. */
+export declare function ownableQualifier(catalogue: PermissionCatalogue, grants: Grants, ownable: string): AccessQualifier | null;
+/** Grants `id` and what it needs; the whose of an ownable one is what the role already holds of its record type, else `own`. */
+export declare function grant(catalogue: PermissionCatalogue, grants: Grants, id: string): void;
+/** Takes `id` away, and what needs it. */
+export declare function revoke(catalogue: PermissionCatalogue, grants: Grants, id: string): void;
+/** Applies one whose to every granted permission of the record type. */
+export declare function setOwnableQualifier(catalogue: PermissionCatalogue, grants: Grants, ownable: string, qualifier: AccessQualifier): void;
+/**
+ * Grants what the granted permissions need but the role lacks (a role saved before a permission gained a
+ * requirement, which the server would refuse as it is). Returns what was added.
+ */
+export declare function completeRequired(catalogue: PermissionCatalogue, grants: Grants): string[];

package/dist/access/context.d.ts

@@ -0,0 +1,20 @@
+import type { RouteLocationRaw } from "vue-router";
+import type { ScopeOptions, SubjectRef } from "../modules/access/entities";
+import type { PermissionCatalogue } from "./catalogue";
+/** What the access screens need from the feature that installed them. */
+export interface AccessContext {
+    readonly catalogue: PermissionCatalogue;
+    /** Where a holder's name leads (their record), or null for a name that is not a link. */
+    readonly subjectRoute: (subject: SubjectRef) => RouteLocationRaw | null;
+    /** The places `subject` may be given roles at; by default what the server says (`GET /v1/iam/users/:id/scopes`). */
+    readonly scopes: ((subject: SubjectRef, signal: AbortSignal) => Promise<ScopeOptions>) | null;
+}
+export declare const accessContextKey: import("vue").InjectionKey<AccessContext>, useAccessContext: () => AccessContext;
+/** The permissions go-core's access module guards its routes with: fixed, so a screen can name them. */
+export declare const accessPermissions: {
+    readonly viewRoles: "iam.role:view";
+    readonly manageRoles: "iam.role:manage";
+    readonly deleteRoles: "iam.role:delete";
+    readonly viewAccess: "iam.user:view";
+    readonly manageBindings: "iam.user:manage";
+};

package/dist/access/effective.d.ts

@@ -0,0 +1,42 @@
+import type { AccessQualifier } from "../platform";
+import type { EffectiveGrant, EffectivePermission, Scope } from "../modules/access/entities";
+import { type PermissionCatalogue } from "./catalogue";
+/** A role that gives a screen's permissions, with the widest whose it gives them at. */
+export interface EffectiveSource {
+    readonly roleKey: string;
+    readonly roleName: string;
+    readonly qualifier: AccessQualifier;
+    readonly scope: Scope;
+}
+/** One permission the person holds, with every grant behind it. */
+export interface EffectiveAction {
+    readonly permission: string;
+    readonly verb: string;
+    /** Granted by a role but switched off for this tenant. */
+    readonly unavailable: boolean;
+    readonly grants: readonly EffectiveGrant[];
+}
+/** One screen: what is held of it, which roles give it, and how wide. */
+export interface EffectiveScreen {
+    readonly key: string;
+    readonly actions: readonly EffectiveAction[];
+    readonly sources: readonly EffectiveSource[];
+    /** The widest whose over the screen's ownable actions; null when none of them is ownable. */
+    readonly qualifier: AccessQualifier | null;
+    /** Where the screen's permissions apply, each place once, the root first. */
+    readonly scopes: readonly Scope[];
+    readonly ownable: boolean;
+    /** Every action here is switched off for the tenant. */
+    readonly allUnavailable: boolean;
+}
+export interface EffectiveGroup {
+    readonly key: string;
+    readonly screens: readonly EffectiveScreen[];
+}
+/**
+ * *What a person can do*: the effective permissions by module and screen, worked out from the roles. The server sends one entry per
+ * permission with every grant behind it (`EffectivePermission.grants`); this turns them into the rows the panel shows: a screen with the
+ * actions held, the roles that give them, and how wide (whose records, which places). A permission the catalogue does not know (a role
+ * saved before it was removed) is grouped by its module and shown by its identifier.
+ */
+export declare function groupEffective(catalogue: PermissionCatalogue, effective: readonly EffectivePermission[]): readonly EffectiveGroup[];

package/dist/access/feature.d.ts

@@ -0,0 +1,27 @@
+import type { RouteLocationRaw } from "vue-router";
+import { type Feature } from "../app";
+import type { ScopeOptions, SubjectRef } from "../modules/access/entities";
+import type { Destination } from "../router";
+import type { PermissionCatalogue } from "./catalogue";
+export interface AccessFeatureOptions {
+    /**
+     * The application's permissions: the `permissions` object go-core's `authzts` writes (`frontend/generated/permissions.ts`).
+     * The role editor's tree is this catalogue; the texts are the application's (`labelKey`, `access.modules.<module>`, ...).
+     */
+    catalogue: PermissionCatalogue;
+    /** Where a holder's name leads (their record). Default: nowhere, the name is not a link. */
+    subjectRoute?: (subject: SubjectRef) => RouteLocationRaw | null;
+    /** The places a person may be given roles at. Default: what the server says (`GET /v1/iam/users/:id/scopes`). */
+    scopes?: (subject: SubjectRef, signal: AbortSignal) => Promise<ScopeOptions>;
+    /** The backend's navigation destination that opens the roles list. Without it the application links to `accessPages.roles` itself. */
+    destination?: Destination;
+}
+/**
+ * The screens of go-core's access module, one feature to install: the roles list (`/iam/roles`), a role's page and the editor of
+ * a new role (`/iam/roles/new`, `?copy=` to start from another role), compare and replace, with every action behind the module's
+ * own permissions (`iam.role:view`, `manage`, `delete`). Pair it with `identityFeature()`; the module's routes must be mounted
+ * on the server (`access.Install`).
+ *
+ *   createApplication({ platform, shell: backofficeShell(), features: [identityFeature(), accessFeature({ catalogue: permissions })] })
+ */
+export declare function accessFeature(options: AccessFeatureOptions): Feature;

package/dist/access/index.d.ts

@@ -0,0 +1,13 @@
+export type * from "../modules/access/entities";
+export type * as Inputs from "../modules/access/schemas";
+export { accessRoutes } from "../modules/access/routes";
+export { accessFeature } from "./feature";
+export type { AccessFeatureOptions } from "./feature";
+export { accessPages, personRolesSection } from "./routes";
+export { accessPermissions } from "./context";
+export { dependantsClosure, permissionTree, requiredClosure } from "./catalogue";
+export type { Grants, PermissionCatalogue, PermissionEntry, PermissionGroup, PermissionMeta, PermissionScreen } from "./catalogue";
+export { useAccessLabels } from "./labels";
+export { useRefusalMessage } from "./refusals";
+export { default as PersonAccess } from "./PersonAccess.vue";
+export { default as BindingRow } from "./BindingRow.vue";

package/dist/access/index.js

@@ -0,0 +1,15 @@
+import { _ as a, i as c, j as o, c as r, b as n, k as i, l as u, p as l, m as p, n as t, u as d, f as m } from "../index-GcLnFF-z.js";
+export {
+  a as BindingRow,
+  c as PersonAccess,
+  o as accessFeature,
+  r as accessPages,
+  n as accessPermissions,
+  i as accessRoutes,
+  u as dependantsClosure,
+  l as permissionTree,
+  p as personRolesSection,
+  t as requiredClosure,
+  d as useAccessLabels,
+  m as useRefusalMessage
+};

package/dist/access/labels.d.ts

@@ -0,0 +1,35 @@
+/** A role as the screens name it: predefined roles by their key, custom ones by the name they were saved with. */
+export interface RoleName {
+    readonly key?: string | null;
+    readonly name: string;
+}
+/** A place as the server names it. */
+export interface ScopeName {
+    readonly level: string;
+    readonly name?: string | null;
+}
+/**
+ * The words of access. The library's own texts are `core.access.*`; the application's catalogue
+ * brings its own: a permission's label and description by the keys the catalogue holds, modules under
+ * `access.modules.<module>`, screens under `access.resources.<module_resource>`, record types under
+ * `access.ownable.<type>`, predefined roles under `access.roles.<key>`, hierarchy levels under
+ * `access.levels.<level>`. A name nobody wrote a text for is shown as it is.
+ */
+export declare function useAccessLabels(): {
+    roleName: (role: RoleName) => string;
+    permissionLabel: (id: string) => string;
+    permissionDescription: (id: string) => string;
+    groupLabel: (group: string) => string;
+    screenLabel: (key: string) => string;
+    ownableLabel: (ownable: string) => string;
+    qualifierLabel: (qualifier: string) => string;
+    qualifierHint: (qualifier: string) => string;
+    qualifierNoun: (qualifier: string) => string;
+    levelLabel: (level: string) => string;
+    /** A place: the level and its name (`Dealer · Auto Zagreb`); the root, which has no name, by its level. */
+    scopeLabel: (scope: ScopeName) => string;
+    roleKind: (role: {
+        predefined: boolean;
+        computed: boolean;
+    }) => string;
+};

package/dist/access/refusals.d.ts

@@ -0,0 +1,6 @@
+/**
+ * For a form's `failureMessage`: a refusal of go-core's delegation rules (`authz.escalation`, `self_assignment`, `last_admin`,
+ * `role_in_use`, ...) says which rule it was, in the app's language (`core.errors.authz.*`, overridable with `errors.authz.*`);
+ * any other failure keeps the form's own sentence for its kind. Call it in `setup`.
+ */
+export declare function useRefusalMessage(): (kind: unknown, error: unknown) => string | undefined;

package/dist/access/routes.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The pages of the access feature as typed targets (`accessPages.role({ ref })`), for a link from the application's own
+ * pages. `/iam/roles/new` is declared before `/iam/roles/:ref`, so "new" is never read as a role's ref.
+ */
+export declare const accessPages: import("../router").DefinedRoutes<{
+    readonly roles: {
+        readonly name: "access.roles";
+        readonly path: "/iam/roles";
+        readonly component: () => Promise<typeof import("./RolesPage.vue")>;
+        readonly meta: {
+            readonly access: "iam.role:view";
+            readonly titleKey: "core.access.title";
+        };
+    };
+    readonly newRole: {
+        readonly name: "access.roles.new";
+        readonly path: "/iam/roles/new";
+        readonly component: () => Promise<typeof import("./NewRolePage.vue")>;
+        readonly meta: {
+            readonly access: "iam.role:manage";
+            readonly titleKey: "core.access.new_title";
+        };
+    };
+    readonly role: {
+        readonly name: "access.role";
+        readonly path: "/iam/roles/:ref";
+        readonly component: () => Promise<typeof import("./RolePage.vue")>;
+        readonly meta: {
+            readonly access: "iam.role:view";
+            readonly titleKey: "core.access.title";
+            readonly remountOnParam: "ref";
+        };
+    };
+}>;
+/**
+ * What a person's record needs to list *Roles* among its sections (`meta` of a child route whose component shows `PersonAccess`): the
+ * label, the icon and the permission go-core guards the person's access with. Spread it into the route's `meta`.
+ */
+export declare const personRolesSection: {
+    readonly access: "iam.user:view";
+    readonly section: {
+        readonly labelKey: "core.access.person_roles";
+        readonly icon: "shieldStarFill";
+    };
+};

package/dist/access/scopes.d.ts

@@ -0,0 +1,20 @@
+import type { ScopeOption, ScopeOptions } from "../modules/access/entities";
+/** A way to say where a role applies: a level of the hierarchy, and the chain of places down to it (a dealer, then its location). */
+export interface ScopeLevel {
+    readonly level: string;
+    /** The levels from just below the root down to this one; empty for the root itself. */
+    readonly chain: readonly string[];
+}
+/**
+ * The levels a person may be given roles at, from what the server says (`GET /v1/iam/users/:id/scopes`): each level that has places,
+ * narrowest first, then the root when roles may be given there. The hierarchy is read off the places (each says its parent level), so
+ * the library knows no level names.
+ */
+export declare function scopeLevels(options: ScopeOptions): readonly ScopeLevel[];
+/** Where to start: the broadest level below the root (the usual choice), else the root. */
+export declare const defaultLevel: (levels: readonly ScopeLevel[]) => ScopeLevel | null;
+/**
+ * The places to choose from at step `index` of `level`'s chain, given what was chosen above (`chosen[i]` is the id at `chain[i]`). A place
+ * that has nothing below it in the chain is left out when the level is deeper: it could not complete a choice.
+ */
+export declare function placesAt(options: ScopeOptions, level: ScopeLevel, index: number, chosen: readonly (number | null)[]): readonly ScopeOption[];

package/dist/app/contributions.d.ts

@@ -1,5 +1,5 @@
 import { type PropType } from "vue";
-import type { Session } from "../platform/session";
+import { type Session } from "../platform/session";
 import type { ShellContribution, ShellSlot } from "./feature";
 /** A contribution with the feature that declared it, for error messages. */
 export interface OwnedContribution {

package/dist/app/feature.d.ts

@@ -20,6 +20,7 @@ export declare function provideContext<T>(key: InjectionKey<T>, value: T): Conte
  *
  * - `headerActions`: the actions of the top bar (a notification bell, a search button)
  * - `accountMenu`: entries of the signed-in user's menu
+ * - `banner`: a strip across the top of the whole shell, above everything (a notice that must stay in view: signed in as somebody else)
  * - `host`: components with no place of their own that must be mounted once (a command palette, a dialog host)
  */
 export interface ShellSlots {
@@ -27,6 +28,7 @@ export interface ShellSlots {
 interface DocumentedShellSlots {
     headerActions: true;
     accountMenu: true;
+    banner: true;
     host: true;
 }
 export type ShellSlot = keyof DocumentedShellSlots | keyof ShellSlots;
@@ -93,6 +95,11 @@ export interface FeatureDefinition {
     effects?: readonly FeatureEffect[];
     /** Capabilities the backend must report (`platform.config.capabilities`); startup fails naming this feature when one is missing. */
     backend?: readonly string[];
+    /**
+     * The feature shows its own prompt when a session expires in the middle of work (a sheet to sign in again), so the
+     * router keeps the person on their page instead of sending them to the login page.
+     */
+    holdsExpiredSession?: boolean;
     /** Features that must be installed too (for a shared integration); checked, never installed for you. */
     requires?: readonly FeatureReference[];
 }
@@ -106,6 +113,7 @@ export interface Feature {
     readonly contributions: readonly ShellContribution[];
     readonly effects: readonly FeatureEffect[];
     readonly backend: readonly string[];
+    readonly holdsExpiredSession: boolean;
     readonly requires: readonly string[];
 }
 /** Whether `value` came from `defineFeature`. */