@wssto2/vue-core 0.11.0 → 0.12.1

package/dist/playwright/index.js

@@ -0,0 +1,403 @@
+const u = (n, s) => ({ success: !0, data: n, ...s === void 0 ? {} : { meta: s } }), te = (n, s = {}) => u(n, { total: n.length, page: 1, per_page: 20, last_page: 1, from: n.length === 0 ? 0 : 1, to: n.length, ...s }), O = (n, s, e = {}) => u({ data: n, total: n.length, per_page: 20, current_page: 1, last_page: 1, from: n.length ? 1 : 0, to: n.length, ...s ? { meta: { views: s } } : {}, ...e }), a = (n, s = 200) => ({ status: s, contentType: "application/json", body: JSON.stringify(n) }), w = () => ({ status: 204, body: "" }), R = (n) => ({ status: 200, contentType: "text/event-stream", body: n.map((s) => `data: ${JSON.stringify(s)}
+
+`).join("") }), j = (n, s, e = {}) => a({ success: !1, error: s, code: s, ...e.params === void 0 ? {} : { params: e.params }, ...e.field ? { fields: { [e.field]: s } } : {} }, n), z = "2099-01-01T00:00:00.000Z", Z = { id: 1, login: "admin", name: "Test Admin", email: "admin@test.com", locale: "en" };
+function M(n, s = {}, e = { level: "organization" }) {
+  const i = e.id === void 0 ? { level: e.level } : { level: e.level, id: e.id };
+  return {
+    subject: { kind: "user", id: 1 },
+    root: e.level === "organization",
+    permissions: Object.fromEntries(n.map((o) => [o, { scope: i, qualifier: s[o] ?? "all", clauses: [] }]))
+  };
+}
+function F(n = [], s = {}) {
+  return { user: Z, expires_at: z, navigation: [], access: M(n), ...s };
+}
+const J = (n = [], s = {}) => u(F(n, s));
+async function ae(n, s = [], e = {}) {
+  await n.route(
+    "**/api/v1/auth/me",
+    (i) => i.fulfill(a(J(s, { user: { ...Z, ...e.user }, navigation: e.navigation ?? [], access: M(s, e.access, e.scope) })))
+  );
+}
+function S(n) {
+  const s = n.request(), e = new URL(s.url()), i = s.method(), o = i === "GET" || !s.postData() ? void 0 : s.postDataJSON();
+  return { method: i, url: e, path: e.pathname.replace(/^\/api\/v1/, ""), body: o };
+}
+const W = { level: "organization", id: null, name: null }, re = (n, s, e) => ({ level: n, id: s, name: e }), D = (n, s = {}) => {
+  const e = /^\d+$/.test(n), i = s.grants ?? [];
+  return {
+    ref: n,
+    id: e ? Number(n) : null,
+    key: e ? null : n,
+    name: `Role ${n}`,
+    description: "",
+    predefined: !e,
+    computed: !1,
+    attrs: [],
+    holders: 0,
+    permission_count: i.length,
+    ...s,
+    grants: i
+  };
+}, U = ({ grants: n, ...s }) => s, B = (n, s, e, i = null) => ({ id: n, role: U(s), scope: e, created_by: i, created_at: "2026-01-01T00:00:00Z" }), le = (n) => j(400, "authz.invalid", { params: { problems: n } }), H = (n, s) => {
+  const e = new Map(n.grants.map((o) => [o.permission, o.qualifier])), i = new Map(s.grants.map((o) => [o.permission, o.qualifier]));
+  return {
+    only_in_role: n.grants.filter((o) => !i.has(o.permission)),
+    only_in_other: s.grants.filter((o) => !e.has(o.permission)),
+    different: n.grants.filter((o) => i.has(o.permission) && i.get(o.permission) !== o.qualifier).map((o) => ({ permission: o.permission, role: o.qualifier, other: i.get(o.permission) }))
+  };
+}, X = (n, s) => {
+  const e = /* @__PURE__ */ new Map();
+  for (const i of n)
+    for (const o of s.find((t) => t.ref === i.role.ref)?.grants ?? []) {
+      const t = e.get(o.permission) ?? { permission: o.permission, unavailable: !1, grants: [] };
+      t.grants.push({ qualifier: o.qualifier, scope: i.scope, attrs: i.role.attrs, binding_id: i.id, role_key: i.role.key ?? "", role_name: i.role.name }), e.set(o.permission, t);
+    }
+  return [...e.values()];
+}, N = (n) => Math.max(0, ...n) + 1;
+async function ce(n, s = {}) {
+  const e = {
+    calls: [],
+    roles: structuredClone(s.roles ?? []),
+    bindings: structuredClone(s.bindings ?? {}),
+    reads: []
+  }, i = s.places ?? { root_level: "organization", root: !0, places: [] };
+  let o = s.next?.role ?? N(e.roles.flatMap((l) => l.id === null ? [] : [l.id])), t = s.next?.binding ?? N(Object.values(e.bindings).flat().map((l) => l.id));
+  const f = (l) => e.roles.find((d) => d.ref === l);
+  return await n.route(/\/api\/v1\/iam\/(roles|bindable-roles|service-accounts\/bindable-roles|users\/\d+\/(access|scopes|bindings)|service-accounts\/\d+\/(access|scopes|bindings))/, async (l) => {
+    var _;
+    const { method: d, url: p, path: v, body: g } = S(l);
+    if (d !== "GET" ? e.calls.push({ method: d, path: v, body: g }) : e.reads.push(`${v}${p.search}`), await s.hook?.(l, p, d, g)) return;
+    if (v === "/iam/bindable-roles" || v === "/iam/service-accounts/bindable-roles") return l.fulfill(a(u({ roles: s.bindable ?? e.roles.filter((r) => r.predefined) })));
+    const m = /^\/iam\/roles(?:\/([^/]+)(?:\/(holders|compare|replace))?)?$/.exec(v);
+    if (m) {
+      const [, r, c] = m;
+      if (!r) {
+        if (d === "GET") return l.fulfill(a(u({ roles: e.roles.map(U) })));
+        const b = g, E = D(String(o++), { name: b.name, description: b.description, grants: b.grants, attrs: b.attrs, holders: 0 });
+        return e.roles.push(E), l.fulfill(a(u(E), 201));
+      }
+      const h = f(r);
+      if (!h) return l.fulfill(a({ success: !1, message: "not found", code: "access.role_not_found" }, 404));
+      if (c === "holders") return l.fulfill(a(u({ holders: s.holders?.[r] ?? [] })));
+      if (c === "compare") {
+        const b = f(p.searchParams.get("with") ?? "");
+        return b ? l.fulfill(a(u(H(h, b)))) : l.fulfill(a({ success: !1, message: "not found" }, 404));
+      }
+      if (c === "replace") return l.fulfill(a(u({ rebound: h.holders })));
+      if (d === "GET") return l.fulfill(a(u(h)));
+      if (d === "DELETE")
+        return e.roles = e.roles.filter((b) => b.ref !== r), l.fulfill(w());
+      const T = g;
+      return Object.assign(h, { name: T.name, description: T.description, grants: T.grants, attrs: T.attrs, permission_count: T.grants.length }), l.fulfill(a(u(h)));
+    }
+    const y = /^\/iam\/(users|service-accounts)\/(\d+)\/(access|scopes|bindings)(?:\/(\d+))?$/.exec(v);
+    if (y) {
+      const [, r, c, h, T] = y, b = `${r === "users" ? "user" : "service"}:${c}`, E = (_ = e.bindings)[b] ?? (_[b] = []);
+      if (h === "scopes") return l.fulfill(a(u(i)));
+      if (h === "access")
+        return l.fulfill(a(u({ subject: { kind: r === "users" ? "user" : "service", id: Number(c) }, bindings: E, effective: X(E, e.roles), can_manage: s.canManage ?? !0 })));
+      if (d === "DELETE")
+        return e.bindings[b] = E.filter((q) => q.id !== Number(T)), l.fulfill(w());
+      const k = g, I = k.level === "organization" ? W : { level: k.level, id: k.scope_id ?? null, name: i.places.find((q) => q.id === k.scope_id && q.level === k.level)?.name ?? null }, P = B(t++, f(k.role_ref) ?? D(k.role_ref), I);
+      return E.push(P), l.fulfill(a(u(P), 201));
+    }
+    return l.fallback();
+  }), e;
+}
+const oe = (n, s, e = {}) => ({
+  id: n,
+  category: e.category ?? "general",
+  title: s,
+  body: e.body ?? "",
+  link: e.link ?? "",
+  data: {},
+  read_at: e.read ? "2026-09-14T11:00:00Z" : null,
+  created_at: "2026-09-14T12:00:00Z"
+}), C = (n, s = "default") => ({ enabled: n, source: s }), Y = (n, s, e = {}) => ({
+  id: n,
+  label: s,
+  platform: "windows",
+  endpoint_hash: `hash-${n}`,
+  active: !0,
+  created_at: "2026-09-10T09:00:00Z",
+  last_seen_at: "2026-09-13T18:00:00Z",
+  last_success_at: null,
+  ...e
+});
+async function fe(n, s = {}) {
+  const e = {
+    calls: [],
+    items: s.items ?? [],
+    unread: 0,
+    categories: s.categories ?? [],
+    quiet: s.quiet ?? { enabled: !0, start: 1260, end: 420 },
+    devices: s.devices ?? [],
+    streams: 0
+  }, i = () => e.unread = s.unread ?? e.items.filter((t) => t.read_at === null).length;
+  i(), await n.route(/\/api\/v1\/notifications(\/|\?|$)/, (t) => o(t));
+  async function o(t) {
+    const { method: f, url: l, body: d } = S(t), p = l.pathname.replace("/api/v1/notifications", "") || "/";
+    f !== "GET" && e.calls.push({ method: f, path: p, body: d });
+    const v = () => a(u({ unread_count: e.unread })), g = () => u({ items: e.devices });
+    if (p === "/stream")
+      return e.streams++, t.fulfill(R(s.stream?.(e.streams, e) ?? [{ type: "unread", unread_count: e.unread }]));
+    if (p === "/" && f === "GET") {
+      if (s.failList?.()) return t.fulfill(a({ success: !1, message: "Server error" }, 500));
+      const r = Number(l.searchParams.get("before_id") ?? 0);
+      return t.fulfill(a(u({ items: e.items.filter((c) => !r || c.id < r), has_more: !1 })));
+    }
+    if (p === "/unread") return t.fulfill(v());
+    if (p === "/read") {
+      const r = d.up_to_id;
+      return e.items.forEach((c) => {
+        c.id <= r && c.read_at === null && (c.read_at = "2026-09-14T12:30:00Z");
+      }), i(), t.fulfill(v());
+    }
+    const m = p.match(/^\/(\d+)\/read$/);
+    if (m) {
+      const r = e.items.find((c) => c.id === Number(m[1]));
+      return r && (r.read_at = "2026-09-14T12:30:00Z"), i(), t.fulfill(v());
+    }
+    if (p === "/preferences")
+      return t.fulfill(a(u({
+        email_available: s.emailAvailable ?? !0,
+        push_available: s.pushAvailable ?? s.push?.enabled ?? !1,
+        categories: e.categories,
+        quiet_hours: e.quiet,
+        time_zone: s.timeZone ?? "UTC"
+      })));
+    const y = p.match(/^\/preferences\/([^/]+?)(\/push)?$/);
+    if (y && f === "PUT") {
+      const r = e.categories.find((c) => c.category === decodeURIComponent(y[1]));
+      return y[2] ? r.push = C(d.push, "person") : r.email = C(d.email, "person"), t.fulfill(a(u(r)));
+    }
+    if (p === "/quiet-hours")
+      return e.quiet = d, t.fulfill(a(u(e.quiet)));
+    if (p === "/push") return t.fulfill(a(u(s.push ?? { enabled: !1, public_key: "" })));
+    if (p === "/devices" && f === "GET") return t.fulfill(a(g()));
+    if (p === "/devices" && f === "POST") {
+      const r = s.registers ?? Y(1, "Mac · Chrome", { platform: "macos" });
+      return e.devices = [r, ...e.devices.filter((c) => c.id !== r.id)], t.fulfill(a(u(r)));
+    }
+    if (p === "/devices/unsubscribe") {
+      const r = s.registers;
+      return e.devices = e.devices.filter((c) => c.endpoint_hash !== r?.endpoint_hash), t.fulfill(a(g()));
+    }
+    const _ = p.match(/^\/devices\/(\d+)(\/test)?$/);
+    if (_) {
+      const r = Number(_[1]);
+      return f === "PATCH" && (e.devices = e.devices.map((c) => c.id === r ? { ...c, label: d.label } : c)), f === "DELETE" && (e.devices = e.devices.filter((c) => c.id !== r)), t.fulfill(a(f === "PATCH" ? u(e.devices.find((c) => c.id === r)) : g()));
+    }
+    return t.fulfill(a(u({})));
+  }
+  return e;
+}
+const K = "2099-01-01T09:30:00.000Z", Q = "2020-01-01T00:00:00.000Z", $ = "new@example.test", A = (n) => new Date(Date.now() - n * 6e4).toISOString(), V = (n = {}) => ({
+  id: 1,
+  login: "admin",
+  name: "Test Admin",
+  email: "admin@test.com",
+  phone: "",
+  locale: "en",
+  created_at: "2025-02-03T10:12:00Z",
+  pending_email: null,
+  ...n
+}), ee = (n = {}) => ({ email: $, expires_at: K, resend_available_at: Q, attempts_left: 3, ...n }), se = (n, s, e = {}) => ({
+  id: n,
+  device: s,
+  ip: "10.20.4.12",
+  opened_by: null,
+  current: !1,
+  last_used_at: A(2),
+  expires_at: new Date(Date.now() + 6 * 36e5).toISOString(),
+  created_at: A(300),
+  ...e
+}), ne = (n, s, e = {}) => ({
+  id: n,
+  event: s,
+  ip: "93.142.8.201",
+  device: "Chrome · Windows",
+  actor: null,
+  created_at: A(n * 20),
+  ...e
+});
+async function ue(n, s = {}) {
+  const e = [], i = s.answers ?? {}, o = () => ee({ email: s.newEmail ?? $ }), t = { profile: s.profile ?? V(), sessions: s.sessions ?? [se(11, "Chrome · Linux", { current: !0 })], signins: s.signins ?? [ne(1, "signed_in")] };
+  return await n.route("**/api/v1/iam/profile**", (f) => {
+    const { method: l, path: d, body: p } = S(f);
+    if (l !== "GET" && e.push({ method: l, path: d, body: p ?? null }), d === "/iam/profile" && l === "GET") return f.fulfill(a(u(t.profile)));
+    if (d === "/iam/profile/email" && l === "POST")
+      return i.request ? f.fulfill(i.request()) : (t.profile = { ...t.profile, pending_email: o() }, f.fulfill(a(u(o()))));
+    if (d === "/iam/profile/email/resend") return f.fulfill(i.resend ? i.resend() : a(u(o())));
+    if (d === "/iam/profile/email/confirm")
+      return i.confirm ? f.fulfill(i.confirm()) : (t.profile = { ...t.profile, email: s.newEmail ?? $, pending_email: null }, f.fulfill(a(u(t.profile))));
+    if (d === "/iam/profile/email" && l === "DELETE")
+      return i.cancel ? f.fulfill(i.cancel()) : (t.profile = { ...t.profile, pending_email: null }, f.fulfill(w()));
+    if (d === "/iam/profile/password") return f.fulfill(i.password ? i.password() : w());
+    if (d === "/iam/profile/sessions" && l === "GET") return f.fulfill(a(u({ sessions: t.sessions })));
+    const v = /^\/iam\/profile\/sessions\/(\d+)$/.exec(d);
+    return v && l === "DELETE" ? (t.sessions = t.sessions.filter((g) => g.id !== Number(v[1])), f.fulfill(w())) : d === "/iam/profile/signins" ? f.fulfill(a(O(t.signins))) : f.fallback();
+  }), { calls: e, state: t };
+}
+const x = (n) => new Date(Date.now() - n * 6e4).toISOString(), G = (n, s, e = {}) => ({
+  id: n,
+  login: s.split(" ")[0].toLowerCase(),
+  name: s,
+  email: `${s.toLowerCase().replace(/[^a-z]+/g, ".")}@example.test`,
+  phone: "",
+  locale: "en",
+  active: !0,
+  status: "active",
+  last_sign_in: null,
+  locked_until: null,
+  created_at: "2025-02-03T10:12:00Z",
+  ...e
+}), de = (n, s, e = {}) => ({
+  id: n,
+  device: s,
+  ip: "10.20.4.12",
+  last_used_at: x(2),
+  expires_at: new Date(Date.now() + 6 * 36e5).toISOString(),
+  created_at: x(300),
+  opened_by: null,
+  current: !1,
+  ...e
+}), me = (n, s, e = {}) => ({
+  id: n,
+  event: s,
+  ip: "93.142.8.201",
+  device: "Chrome · Windows",
+  actor: null,
+  created_at: x(n * 20),
+  ...e
+}), pe = (n, s, e = {}) => ({
+  id: n,
+  action: s,
+  fields: [],
+  before: {},
+  after: {},
+  actor: { id: 4, name: "Test Manager" },
+  created_at: x(n * 90),
+  ...e
+}), ge = (n, s, e, i, o = {}) => ({
+  id: n,
+  area: "general",
+  record_type: s,
+  record_id: e,
+  action: i,
+  signed_in_as: null,
+  created_at: x(n * 40),
+  ...o
+}), ve = (n, s, e = {}) => ({
+  id: n,
+  name: s,
+  description: "",
+  tenant: null,
+  owner: { id: 1, name: "Test Admin" },
+  created_by: { id: 1, name: "Test Admin" },
+  created_at: "2026-09-12T10:00:00Z",
+  active_keys: 1,
+  last_used_at: x(3),
+  deactivated_at: null,
+  ...e
+}), ie = (n = {}) => ({
+  people: [],
+  sessions: [],
+  signins: [],
+  changes: [],
+  activity: [],
+  serviceAccounts: [],
+  keys: {},
+  notManageable: !1,
+  ...n
+}), L = (n) => a({ success: !1, error: "not found", message: "not found", ...n ? { code: n } : {} }, 404);
+async function he(n, s = {}) {
+  const e = s.writes ?? [], i = s.state ?? ie(), o = ({ method: t, path: f, url: l, body: d }) => {
+    if (f === "/iam/users" && t === "GET") {
+      const g = l.searchParams.get("view") ?? "active", m = (l.searchParams.get("search") ?? "").toLowerCase(), y = i.people.filter((r) => (!m || r.name.toLowerCase().includes(m)) && (s.filter?.(r, l.searchParams) ?? !0)), _ = (r) => y.filter((c) => r === "all" || c.status === r).length;
+      return a(O(y.filter((r) => g === "all" || r.status === g), ["active", "locked", "inactive", "all"].map((r) => ({ key: r, count: _(r) }))));
+    }
+    if (f === "/iam/users" && t === "POST") {
+      const g = d, m = G(Math.max(0, ...i.people.map((y) => y.id)) + 1, g.name, g);
+      return i.people.push(m), a(u(m));
+    }
+    const p = /^\/iam\/users\/(\d+)(?:\/(.*))?$/.exec(f);
+    if (p) {
+      const g = Number(p[1]), m = p[2] ?? "", _ = i.people.find((c) => c.id === g) ?? G(g, "Unknown Person");
+      if (m === "") {
+        if (t === "PUT") {
+          const c = d, h = c.ext === void 0 ? _.ext : { ..._.ext, ...c.ext };
+          return a(u({ ..._, ...c, ...h === void 0 ? {} : { ext: h } }));
+        }
+        return t === "DELETE" ? w() : a(u(_));
+      }
+      if (m === "sessions" && t === "GET") return a(u({ sessions: i.sessions }));
+      if (m === "sessions" && t === "DELETE")
+        return i.sessions = [], w();
+      const r = /^sessions\/(\d+)$/.exec(m);
+      if (r && t === "DELETE")
+        return i.sessions = i.sessions.filter((c) => c.id !== Number(r[1])), w();
+      if (m === "signins") {
+        const h = l.searchParams.get("view") === "failed" ? i.signins.filter((T) => ["wrong_password", "locked_out", "refused_inactive"].includes(T.event)) : i.signins;
+        return a(O(h, [{ key: "all", count: i.signins.length }, { key: "failed", count: i.signins.filter((T) => ["wrong_password", "locked_out", "refused_inactive"].includes(T.event)).length }]));
+      }
+      if (m === "changes") return a(O(i.changes, [{ key: "all", count: i.changes.length }]));
+      if (m === "activity") {
+        const c = l.searchParams.get("area");
+        return a(O(c ? i.activity.filter((h) => h.area === c) : i.activity, [{ key: "all", count: i.activity.length }]));
+      }
+      return m === "deactivate" || m === "activate" ? a(u({})) : m === "password" ? w() : m === "unlock" ? (_.locked_until = null, _.status = "active", a(u({ unlocked: !0 }))) : void 0;
+    }
+    if (f === "/iam/service-accounts") return a(u({ service_accounts: i.serviceAccounts }));
+    const v = /^\/iam\/service-accounts\/(\d+)(?:\/(keys))?$/.exec(f);
+    if (v && t === "GET") {
+      const g = i.serviceAccounts.find((m) => m.id === Number(v[1]));
+      return g ? a(u(v[2] ? { keys: i.keys[g.id] ?? [] } : g)) : L();
+    }
+  };
+  return await n.route(/\/api\/v1\/iam\/(users|service-accounts)(\/|\?|$)/, (t) => {
+    const { method: f, url: l, path: d, body: p } = S(t), v = { method: f, path: d, url: l, body: p }, m = (f !== "GET" && i.notManageable && /^\/iam\/users\/\d+/.test(d) ? L("identity.account.not_found") : void 0) ?? s.hook?.(v, i) ?? o(v);
+    return m ? (f !== "GET" && e.push({ method: f, path: d, body: p ?? null }), t.fulfill(m)) : t.fallback();
+  }), { writes: e, state: i };
+}
+export {
+  $ as NEW_EMAIL,
+  W as ORGANIZATION,
+  M as accessOf,
+  ge as activity,
+  x as ago,
+  J as authBody,
+  F as authResponse,
+  B as bindingOf,
+  pe as change,
+  O as datatable,
+  Z as defaultUser,
+  Y as device,
+  ie as freshState,
+  le as invalid,
+  a as json,
+  ae as mockAuth,
+  w as noContent,
+  oe as notification,
+  u as ok,
+  se as ownSession,
+  ne as ownSignin,
+  te as pageOk,
+  ee as pendingChange,
+  G as person,
+  V as profile,
+  j as refusal,
+  D as role,
+  re as scopeOf,
+  ce as serveAccess,
+  fe as serveNotifications,
+  ue as serveProfile,
+  he as serveUsers,
+  ve as serviceAccount,
+  de as session,
+  C as setting,
+  me as signin,
+  R as sse,
+  U as summary
+};

package/dist/playwright/notifications.d.ts

@@ -0,0 +1,48 @@
+import type { Page } from "@playwright/test";
+import type { CategorySettings, Device, Item, PushConfig, QuietHours, Setting, Source, StreamEvent } from "../modules/notification/entities";
+import { type Call } from "./request";
+/**
+ * go-core's notification wire as it serves it under `/api/v1/notifications`, for the specs that open the bell, the settings or the
+ * failed-events page: the inbox, the live stream, the preferences, push and the devices. A fake with a little state (items, unread
+ * count, preferences, devices), so a spec reads what it did through `calls`. The page needs `mockAuth` too.
+ */
+export type { CategorySettings, Device, Item, QuietHours, Setting };
+export type { Call } from "./request";
+export declare const notification: (id: number, title: string, options?: {
+    read?: boolean;
+    category?: string;
+    link?: string;
+    body?: string;
+}) => Item;
+export declare const setting: (enabled: boolean, source?: Source) => Setting;
+export declare const device: (id: number, label: string, options?: Partial<Device>) => Device;
+export type WireOptions = {
+    items?: Item[];
+    /** The unread count the server says; default the number of unread items. */
+    unread?: number;
+    categories?: CategorySettings[];
+    /** Minutes after midnight: 1260 is 21:00. */
+    quiet?: QuietHours;
+    timeZone?: string;
+    emailAvailable?: boolean;
+    pushAvailable?: boolean;
+    push?: PushConfig;
+    devices?: Device[];
+    /** The device a registration creates (the browser's own). */
+    registers?: Device;
+    /** What each connection of the live stream sends, by its number from 1; default one `unread` snapshot. */
+    stream?: (connection: number, state: Wire) => StreamEvent[];
+    /** Fails the inbox list while true. */
+    failList?: () => boolean;
+};
+export type Wire = {
+    calls: Call[];
+    items: Item[];
+    unread: number;
+    categories: CategorySettings[];
+    quiet: QuietHours;
+    devices: Device[];
+    streams: number;
+};
+/** Answers every `/api/v1/notifications/**` route like go-core. */
+export declare function serveNotifications(page: Page, options?: WireOptions): Promise<Wire>;

package/dist/playwright/profile.d.ts

@@ -0,0 +1,35 @@
+import type { Page } from "@playwright/test";
+import type { PendingEmail, ProfileResponse, SessionItem, SignInRow } from "../modules/identity/entities";
+import { type Answer } from "./envelope";
+import { type Call } from "./request";
+/**
+ * "My profile" as the identity module serves it (`/api/v1/iam/profile…`, go-core `ProfileResponse`): the record, the e-mail change
+ * with its confirmation, the password, the person's own sessions and sign-ins. Every write is reported with its body; an endpoint
+ * answers as `answers` says (success when absent). Routes your application adds under `iam/profile` are yours: register them
+ * after this, they run first, and this answers the rest.
+ */
+export type ProfileCall = Call;
+/** The address a confirmed e-mail change ends with (default; `newEmail` changes it). */
+export declare const NEW_EMAIL = "new@example.test";
+export declare const profile: (overrides?: Partial<ProfileResponse>) => ProfileResponse;
+export declare const pendingChange: (overrides?: Partial<PendingEmail>) => PendingEmail;
+export declare const ownSession: (id: number, device: string, overrides?: Partial<SessionItem>) => SessionItem;
+export declare const ownSignin: (id: number, event: SignInRow["event"], overrides?: Partial<SignInRow>) => SignInRow;
+export type ProfileAnswers = Partial<Record<"request" | "confirm" | "resend" | "cancel" | "password", () => Answer>>;
+export type ProfileOptions = {
+    profile?: ProfileResponse;
+    answers?: ProfileAnswers;
+    sessions?: SessionItem[];
+    signins?: SignInRow[];
+    /** The address a request is for and a confirmation lands on (default `NEW_EMAIL`). */
+    newEmail?: string;
+};
+/** Registers the profile routes (after `mockAuth`). */
+export declare function serveProfile(page: Page, options?: ProfileOptions): Promise<{
+    calls: Call[];
+    state: {
+        profile: ProfileResponse;
+        sessions: SessionItem[];
+        signins: SignInRow[];
+    };
+}>;

package/dist/playwright/request.d.ts

@@ -0,0 +1,14 @@
+import type { Route } from "@playwright/test";
+/** What a handler needs of a request: its method, the path below `/api/v1`, the query and the JSON body (undefined for a read or an empty body). */
+export declare function readRequest(route: Route): {
+    method: string;
+    url: URL;
+    path: string;
+    body: unknown;
+};
+/** One write a mock saw: a spec reads what the page sent through these. */
+export type Call = {
+    method: string;
+    path: string;
+    body: unknown;
+};

package/dist/playwright/session.d.ts

@@ -0,0 +1,48 @@
+import type { Page } from "@playwright/test";
+import type { AccessQualifier } from "../platform";
+import type { MyAccess, Node, SessionResponse, User } from "../modules/identity/entities";
+/** The signed-in person a spec starts with: only what go-core's identity returns. An app adds its own fields through `mockAuth`'s `user`. */
+export declare const defaultUser: User;
+export type MockAuthOptions = {
+    /** The signed-in user's navigation (default none). */
+    navigation?: Node[];
+    /** Fields merged over `defaultUser`: a different person, or the fields your application adds to the user. */
+    user?: Partial<User> & Record<string, unknown>;
+    /** The qualifier each permission is held at (default `all`), e.g. `{ "crm.lead:view": "own_location" }`. */
+    access?: Record<string, AccessQualifier>;
+    /** Where every permission is held (default the organization, which is the root: no id). */
+    scope?: HeldAt;
+};
+/** Where a permission is held: the organization, or a place of a level (`{ level: "dealer", id: 1 }`). */
+export type HeldAt = {
+    level: string;
+    id?: number;
+};
+/** Fields of the session payload to set or replace (an `impersonator`, another `expires_at`), and any the application adds. */
+export type SessionExtra = Partial<Omit<SessionResponse, "access">> & {
+    access?: MyAccess;
+} & Record<string, unknown>;
+/** The `/auth/me` `access` payload for the given permissions, every one at `scope` with its qualifier. The organization has no id: it is go-core's root scope, and `root` says a binding is there. */
+export declare function accessOf(policies: string[], qualifiers?: Record<string, AccessQualifier>, scope?: HeldAt): MyAccess;
+/** The session payload of go-core's identity (`/auth/me`, `/auth/refresh`, `/auth/login-as`), without its envelope. */
+export declare function authResponse(policies?: string[], extra?: SessionExtra): {
+    navigation: Node[];
+    user: unknown;
+    impersonator?: (import("../identity").Impersonator | null) | undefined;
+    expires_at: string;
+    access: MyAccess;
+};
+/** The same, as the server sends it: inside go-core's `{ success, data }` envelope. */
+export declare const authBody: (policies?: string[], extra?: SessionExtra) => {
+    meta?: {} | null | undefined;
+    success: true;
+    data: {
+        navigation: Node[];
+        user: unknown;
+        impersonator?: (import("../identity").Impersonator | null) | undefined;
+        expires_at: string;
+        access: MyAccess;
+    };
+};
+/** Signs the page in: answers go-core identity's `GET /api/v1/auth/me` with a session that holds `policies`. */
+export declare function mockAuth(page: Page, policies?: string[], options?: MockAuthOptions): Promise<void>;

package/dist/playwright/users.d.ts

@@ -0,0 +1,57 @@
+import type { Page } from "@playwright/test";
+import type { ActivityRow, ChangeRow, SessionItem, SignInRow, UserDetail } from "../modules/identity/entities";
+import type { ApiKey, ServiceAccount } from "../modules/serviceaccount/entities";
+import { type Answer } from "./envelope";
+import { type Call } from "./request";
+/**
+ * The people of the identity module as it serves them under `/api/v1/iam/users` (list with its views, one person's record, sessions,
+ * sign-ins, changes, activity, unlock, activate) and the service accounts of `/api/v1/iam/service-accounts` (list, record, keys).
+ * Every write is reported with its body. Only these paths are answered: the rest of the application's API, the access routes
+ * (`serveAccess`) and what your application adds to a person (`ext`) are yours. The rules themselves are the server's tests'.
+ */
+export type Write = Call;
+export declare const ago: (minutes: number) => string;
+/** A person as go-core's list row and record carry them (`UserRow` / `UserDetail`; the same shape). */
+export declare const person: (id: number, name: string, overrides?: Partial<UserDetail>) => UserDetail;
+/** A live session of a person (`SessionItem`). */
+export declare const session: (id: number, device: string, overrides?: Partial<SessionItem>) => SessionItem;
+/** A row of the sign-in history (`SignInRow`). */
+export declare const signin: (id: number, event: SignInRow["event"], overrides?: Partial<SignInRow>) => SignInRow;
+/** A change to the person (`ChangeRow`). */
+export declare const change: (id: number, action: ChangeRow["action"], overrides?: Partial<ChangeRow>) => ChangeRow;
+/** What a person did (`ActivityRow`). */
+export declare const activity: (id: number, recordType: string, recordId: number, action: ActivityRow["action"], overrides?: Partial<ActivityRow>) => ActivityRow;
+export declare const serviceAccount: (id: number, name: string, overrides?: Partial<ServiceAccount>) => ServiceAccount;
+export type UsersState = {
+    people: UserDetail[];
+    sessions: SessionItem[];
+    signins: SignInRow[];
+    changes: ChangeRow[];
+    activity: ActivityRow[];
+    serviceAccounts: ServiceAccount[];
+    /** The keys of each service account, by its id. */
+    keys: Record<number, ApiKey[]>;
+    /** Whether the person's record answers `404` on manage actions (seen but not managed). */
+    notManageable: boolean;
+};
+export declare const freshState: (overrides?: Partial<UsersState>) => UsersState;
+export type UsersRequest = {
+    method: string;
+    path: string;
+    url: URL;
+    body: unknown;
+};
+export type UsersOptions = {
+    state?: UsersState;
+    /** Where the writes are reported (default a new array, returned). */
+    writes?: Write[];
+    /** Whether a person is in the list for these query parameters, besides the view and the search (your `ext` filters). */
+    filter?: (person: UserDetail, params: URLSearchParams) => boolean;
+    /** Answers first (after `notManageable`): an answer is served (and a write reported), undefined leaves the request to the routes below. */
+    hook?: (request: UsersRequest, state: UsersState) => Answer | undefined;
+};
+/** Serves the users module; every write (with its JSON body) is reported, and the state can be changed by a spec. */
+export declare function serveUsers(page: Page, options?: UsersOptions): Promise<{
+    writes: Call[];
+    state: UsersState;
+}>;