@byline/admin 2.4.0 → 2.4.1

package/dist/modules/admin-roles/schemas.js

@@ -1,83 +1,57 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-import { uuidSchema } from '@byline/core/validation';
-import { z } from 'zod';
-/**
- * Zod request/response schemas for the admin-roles commands.
- *
- * `vid` gates writes for optimistic concurrency; `machine_name` is
- * accepted only at create time and validated as a slug-shaped string.
- *
- * Reorder takes the full ordered id list — the index in the array
- * becomes each role's new `order` value. The list-view UX is "drag,
- * then save the whole order" so a partial-update payload would add no
- * value and complicate atomicity.
- */
-// ---------------------------------------------------------------------------
-// Field-level schemas
-// ---------------------------------------------------------------------------
+import { uuidSchema } from "@byline/core/validation";
+import { z } from "zod";
 const idSchema = uuidSchema;
-const vidSchema = z
-    .number({ message: 'vid is required' })
-    .int({ message: 'vid must be an integer' })
-    .positive({ message: 'vid must be positive' });
+const vidSchema = z.number({
+    message: 'vid is required'
+}).int({
+    message: 'vid must be an integer'
+}).positive({
+    message: 'vid must be positive'
+});
 const nameSchema = z.string().min(1).max(128);
-const machineNameSchema = z
-    .string()
-    .min(1)
-    .max(128)
-    .regex(/^[a-z0-9][a-z0-9_-]*$/, {
-    message: 'machine_name may contain lowercase letters, numbers, hyphens, and underscores only',
+const machineNameSchema = z.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9_-]*$/, {
+    message: 'machine_name may contain lowercase letters, numbers, hyphens, and underscores only'
 });
 const descriptionSchema = z.string().max(2000).nullish();
 const orderSchema = z.number().int().min(0);
-// ---------------------------------------------------------------------------
-// Requests
-// ---------------------------------------------------------------------------
-export const listAdminRolesRequestSchema = z.object({}).optional();
-export const getAdminRoleRequestSchema = z.object({
-    id: idSchema,
+const listAdminRolesRequestSchema = z.object({}).optional();
+const getAdminRoleRequestSchema = z.object({
+    id: idSchema
 });
-export const createAdminRoleRequestSchema = z.object({
+const createAdminRoleRequestSchema = z.object({
     name: nameSchema,
     machine_name: machineNameSchema,
     description: descriptionSchema,
-    order: orderSchema.optional(),
+    order: orderSchema.optional()
 });
-export const updateAdminRoleRequestSchema = z.object({
+const updateAdminRoleRequestSchema = z.object({
     id: idSchema,
     vid: vidSchema,
-    patch: z
-        .object({
+    patch: z.object({
         name: nameSchema.optional(),
         description: descriptionSchema,
-        order: orderSchema.optional(),
+        order: orderSchema.optional()
+    }).refine((p)=>Object.keys(p).length > 0, {
+        message: 'patch cannot be empty'
     })
-        .refine((p) => Object.keys(p).length > 0, { message: 'patch cannot be empty' }),
 });
-export const deleteAdminRoleRequestSchema = z.object({
+const deleteAdminRoleRequestSchema = z.object({
     id: idSchema,
-    vid: vidSchema,
+    vid: vidSchema
 });
-export const reorderAdminRolesRequestSchema = z.object({
-    ids: z.array(idSchema).min(1, { message: 'at least one id is required' }),
+const reorderAdminRolesRequestSchema = z.object({
+    ids: z.array(idSchema).min(1, {
+        message: 'at least one id is required'
+    })
 });
-export const getRolesForUserRequestSchema = z.object({
-    userId: idSchema,
+const getRolesForUserRequestSchema = z.object({
+    userId: idSchema
 });
-export const setRolesForUserRequestSchema = z.object({
+const setRolesForUserRequestSchema = z.object({
     userId: idSchema,
-    roleIds: z.array(idSchema),
+    roleIds: z.array(idSchema)
 });
-// ---------------------------------------------------------------------------
-// Responses
-// ---------------------------------------------------------------------------
-export const adminRoleResponseSchema = z.object({
+const adminRoleResponseSchema = z.object({
     id: z.string(),
     vid: z.number().int(),
     name: z.string(),
@@ -85,20 +59,16 @@ export const adminRoleResponseSchema = z.object({
     description: z.string().nullable(),
     order: z.number().int(),
     created_at: z.date(),
-    updated_at: z.date(),
+    updated_at: z.date()
 });
-export const adminRoleListResponseSchema = z.object({
-    roles: z.array(adminRoleResponseSchema),
+const adminRoleListResponseSchema = z.object({
+    roles: z.array(adminRoleResponseSchema)
 });
-/**
- * User-roles editor payload. `userId` is echoed back so the caller can
- * match async writes; `roles` is the authoritative role-set after the
- * write, shaped as full role rows so the drawer renders names without a
- * second fetch.
- */
-export const userRolesResponseSchema = z.object({
+const userRolesResponseSchema = z.object({
     userId: z.string(),
-    roles: z.array(adminRoleResponseSchema),
+    roles: z.array(adminRoleResponseSchema)
+});
+const okResponseSchema = z.object({
+    ok: z.literal(true)
 });
-/** Empty response for void-returning mutations (delete, reorder). */
-export const okResponseSchema = z.object({ ok: z.literal(true) });
+export { adminRoleListResponseSchema, adminRoleResponseSchema, createAdminRoleRequestSchema, deleteAdminRoleRequestSchema, getAdminRoleRequestSchema, getRolesForUserRequestSchema, listAdminRolesRequestSchema, okResponseSchema, reorderAdminRolesRequestSchema, setRolesForUserRequestSchema, updateAdminRoleRequestSchema, userRolesResponseSchema };

package/dist/modules/admin-roles/service.js

@@ -1,109 +1,106 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-import { toAdminRole } from './dto.js';
-import { ERR_ADMIN_ROLE_MACHINE_NAME_IN_USE, ERR_ADMIN_ROLE_NOT_FOUND, ERR_ADMIN_ROLE_USER_NOT_FOUND, } from './errors.js';
-/**
- * Business logic for administering admin roles.
- *
- * Owns four concerns the repository deliberately avoids:
- *
- *   1. **Domain invariants.** `machine_name` uniqueness pre-check on
- *      create — the unique index is the ultimate backstop, but the
- *      pre-check produces a clean domain error rather than a raw
- *      Postgres code.
- *   2. **DTO shaping.** Raw rows are shaped through `toAdminRole` so
- *      the response contract is owned in one place.
- *   3. **Optimistic-concurrency plumbing.** The repo gates writes on
- *      `expectedVid`; the service threads it from the validated request
- *      shape. Version conflicts surface as
- *      `AdminRolesError(VERSION_CONFLICT)` from the adapter; the service
- *      does not catch them.
- *   4. **Cross-table validation.** The user-roles editor validates the
- *      user and every referenced role exists before mutating the join
- *      table — clean errors over raw FK violations.
- *
- * Roles do not need a self-target invariant the way users do
- * (no "self-delete" concept), so role-CRUD service methods are
- * actor-agnostic and the ability check at the command boundary is the
- * only authorisation.
- */
-export class AdminRolesService {
-    #store;
-    constructor(deps) {
-        this.#store = deps.store;
+import { toAdminRole } from "./dto.js";
+import { ERR_ADMIN_ROLE_MACHINE_NAME_IN_USE, ERR_ADMIN_ROLE_NOT_FOUND, ERR_ADMIN_ROLE_USER_NOT_FOUND } from "./errors.js";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
     }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var _store = /*#__PURE__*/ new WeakMap();
+class AdminRolesService {
     async listRoles() {
-        const rows = await this.#store.adminRoles.list();
-        return { roles: rows.map(toAdminRole) };
+        const rows = await _class_private_field_get(this, _store).adminRoles.list();
+        return {
+            roles: rows.map(toAdminRole)
+        };
     }
     async getRole(request) {
-        const row = await this.#store.adminRoles.getById(request.id);
-        if (!row)
-            throw ERR_ADMIN_ROLE_NOT_FOUND();
+        const row = await _class_private_field_get(this, _store).adminRoles.getById(request.id);
+        if (!row) throw ERR_ADMIN_ROLE_NOT_FOUND();
         return toAdminRole(row);
     }
     async createRole(request) {
-        // Pre-check for machine_name conflict so the common case returns a
-        // domain-specific error rather than the raw unique-violation code.
-        const existing = await this.#store.adminRoles.getByMachineName(request.machine_name);
-        if (existing)
-            throw ERR_ADMIN_ROLE_MACHINE_NAME_IN_USE();
-        const row = await this.#store.adminRoles.create({
+        const existing = await _class_private_field_get(this, _store).adminRoles.getByMachineName(request.machine_name);
+        if (existing) throw ERR_ADMIN_ROLE_MACHINE_NAME_IN_USE();
+        const row = await _class_private_field_get(this, _store).adminRoles.create({
             name: request.name,
             machine_name: request.machine_name,
             description: request.description ?? null,
-            order: request.order,
+            order: request.order
         });
         return toAdminRole(row);
     }
     async updateRole(request) {
-        const current = await this.#store.adminRoles.getById(request.id);
-        if (!current)
-            throw ERR_ADMIN_ROLE_NOT_FOUND();
-        const row = await this.#store.adminRoles.update(request.id, request.vid, request.patch);
+        const current = await _class_private_field_get(this, _store).adminRoles.getById(request.id);
+        if (!current) throw ERR_ADMIN_ROLE_NOT_FOUND();
+        const row = await _class_private_field_get(this, _store).adminRoles.update(request.id, request.vid, request.patch);
         return toAdminRole(row);
     }
     async deleteRole(request) {
-        const exists = await this.#store.adminRoles.getById(request.id);
-        if (!exists)
-            throw ERR_ADMIN_ROLE_NOT_FOUND();
-        await this.#store.adminRoles.delete(request.id, request.vid);
+        const exists = await _class_private_field_get(this, _store).adminRoles.getById(request.id);
+        if (!exists) throw ERR_ADMIN_ROLE_NOT_FOUND();
+        await _class_private_field_get(this, _store).adminRoles.delete(request.id, request.vid);
     }
     async reorderRoles(request) {
-        await this.#store.adminRoles.reorder(request.ids);
+        await _class_private_field_get(this, _store).adminRoles.reorder(request.ids);
     }
     async getRolesForUser(request) {
-        const user = await this.#store.adminUsers.getById(request.userId);
-        if (!user)
-            throw ERR_ADMIN_ROLE_USER_NOT_FOUND();
-        const rows = await this.#store.adminRoles.listRolesForUser(request.userId);
-        return { userId: request.userId, roles: rows.map(toAdminRole) };
+        const user = await _class_private_field_get(this, _store).adminUsers.getById(request.userId);
+        if (!user) throw ERR_ADMIN_ROLE_USER_NOT_FOUND();
+        const rows = await _class_private_field_get(this, _store).adminRoles.listRolesForUser(request.userId);
+        return {
+            userId: request.userId,
+            roles: rows.map(toAdminRole)
+        };
     }
     async setRolesForUser(request) {
-        const user = await this.#store.adminUsers.getById(request.userId);
-        if (!user)
-            throw ERR_ADMIN_ROLE_USER_NOT_FOUND();
-        // Validate every referenced role exists. N round-trips, but role
-        // assignment payloads are small by design (typically < 10 roles)
-        // and surfacing a clean `notFound` beats a raw FK violation.
+        const user = await _class_private_field_get(this, _store).adminUsers.getById(request.userId);
+        if (!user) throw ERR_ADMIN_ROLE_USER_NOT_FOUND();
         if (request.roleIds.length > 0) {
-            const found = await Promise.all(request.roleIds.map((id) => this.#store.adminRoles.getById(id)));
-            const missing = request.roleIds.filter((_, i) => found[i] == null);
-            if (missing.length > 0) {
-                throw ERR_ADMIN_ROLE_NOT_FOUND({
-                    message: `One or more referenced roles do not exist: ${missing.join(', ')}`,
-                });
-            }
+            const found = await Promise.all(request.roleIds.map((id)=>_class_private_field_get(this, _store).adminRoles.getById(id)));
+            const missing = request.roleIds.filter((_, i)=>null == found[i]);
+            if (missing.length > 0) throw ERR_ADMIN_ROLE_NOT_FOUND({
+                message: `One or more referenced roles do not exist: ${missing.join(', ')}`
+            });
         }
-        await this.#store.adminRoles.setRolesForUser(request.userId, request.roleIds);
-        // Return the freshly stored set, shaped — saves the editor a second
-        // round-trip and guards against any normalisation the repo might apply.
-        const stored = await this.#store.adminRoles.listRolesForUser(request.userId);
-        return { userId: request.userId, roles: stored.map(toAdminRole) };
+        await _class_private_field_get(this, _store).adminRoles.setRolesForUser(request.userId, request.roleIds);
+        const stored = await _class_private_field_get(this, _store).adminRoles.listRolesForUser(request.userId);
+        return {
+            userId: request.userId,
+            roles: stored.map(toAdminRole)
+        };
+    }
+    constructor(deps){
+        _class_private_field_init(this, _store, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_set(this, _store, deps.store);
     }
 }
+export { AdminRolesService };

package/dist/modules/admin-users/abilities.js

@@ -1,69 +1,40 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-/**
- * Ability keys for the admin-users module.
- *
- * Dot-notation rather than Modulus' colon-notation — keeps one consistent
- * hierarchy across the whole platform alongside `collections.<path>.<verb>`
- * from core.
- *
- * `changePassword` is split out from `update` deliberately: setting
- * someone else's password is a higher-trust operation than editing their
- * profile fields, and the role editor UI benefits from naming it
- * explicitly. A role can grant `update` without implicitly granting
- * `changePassword`.
- *
- * Self-service (changing *own* password, email, etc.) does **not** use
- * any of these keys. That flow lives in the separate `account` module
- * where the actor is the target by definition; the `admin.users.*` keys
- * are strictly for administering other admin users.
- */
-export const ADMIN_USERS_ABILITIES = {
+const ADMIN_USERS_ABILITIES = {
     read: 'admin.users.read',
     create: 'admin.users.create',
     update: 'admin.users.update',
     delete: 'admin.users.delete',
-    changePassword: 'admin.users.changePassword',
+    changePassword: 'admin.users.changePassword'
 };
-/**
- * Register every admin-users ability with the framework's `AbilityRegistry`.
- * Called from `registerAdminAbilities(registry)` at package level, which
- * the webapp wires into `initBylineCore()`.
- */
-export function registerAdminUsersAbilities(registry) {
+function registerAdminUsersAbilities(registry) {
     registry.register({
         key: ADMIN_USERS_ABILITIES.read,
         label: 'Read admin users',
         group: 'admin.users',
-        source: 'admin',
+        source: 'admin'
     });
     registry.register({
         key: ADMIN_USERS_ABILITIES.create,
         label: 'Create admin users',
         group: 'admin.users',
-        source: 'admin',
+        source: 'admin'
     });
     registry.register({
         key: ADMIN_USERS_ABILITIES.update,
         label: 'Update admin users',
         group: 'admin.users',
-        source: 'admin',
+        source: 'admin'
     });
     registry.register({
         key: ADMIN_USERS_ABILITIES.delete,
         label: 'Delete admin users',
         group: 'admin.users',
-        source: 'admin',
+        source: 'admin'
     });
     registry.register({
         key: ADMIN_USERS_ABILITIES.changePassword,
         label: "Change an admin user's password",
         group: 'admin.users',
-        source: 'admin',
+        source: 'admin'
     });
 }
+export { ADMIN_USERS_ABILITIES, registerAdminUsersAbilities };

package/dist/modules/admin-users/commands.js

@@ -1,71 +1,113 @@
-/**
- * This Source Code is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * Copyright (c) Infonomic Company Limited
- */
-import { createCommand } from '../../lib/create-command.js';
-import { ADMIN_USERS_ABILITIES } from './abilities.js';
-import { adminUserListResponseSchema, adminUserResponseSchema, createAdminUserRequestSchema, deleteAdminUserRequestSchema, disableAdminUserRequestSchema, enableAdminUserRequestSchema, getAdminUserRequestSchema, listAdminUsersRequestSchema, okResponseSchema, setAdminUserPasswordRequestSchema, updateAdminUserRequestSchema, } from './schemas.js';
-import { AdminUsersService } from './service.js';
+import { createCommand } from "../../lib/create-command.js";
+import { ADMIN_USERS_ABILITIES } from "./abilities.js";
+import { adminUserListResponseSchema, adminUserResponseSchema, createAdminUserRequestSchema, deleteAdminUserRequestSchema, disableAdminUserRequestSchema, enableAdminUserRequestSchema, getAdminUserRequestSchema, listAdminUsersRequestSchema, okResponseSchema, setAdminUserPasswordRequestSchema, updateAdminUserRequestSchema } from "./schemas.js";
+import { AdminUsersService } from "./service.js";
 function serviceOf(deps) {
-    return new AdminUsersService({ repo: deps.store.adminUsers });
+    return new AdminUsersService({
+        repo: deps.store.adminUsers
+    });
 }
-export const listAdminUsersCommand = createCommand({
+const listAdminUsersCommand = createCommand({
     method: 'listAdminUsers',
-    auth: { ability: ADMIN_USERS_ABILITIES.read },
-    schemas: { input: listAdminUsersRequestSchema, output: adminUserListResponseSchema },
-    handler: ({ input, deps }) => serviceOf(deps).listUsers(input),
+    auth: {
+        ability: ADMIN_USERS_ABILITIES.read
+    },
+    schemas: {
+        input: listAdminUsersRequestSchema,
+        output: adminUserListResponseSchema
+    },
+    handler: ({ input, deps })=>serviceOf(deps).listUsers(input)
 });
-export const getAdminUserCommand = createCommand({
+const getAdminUserCommand = createCommand({
     method: 'getAdminUser',
-    auth: { ability: ADMIN_USERS_ABILITIES.read },
-    schemas: { input: getAdminUserRequestSchema, output: adminUserResponseSchema },
-    handler: ({ input, deps }) => serviceOf(deps).getUser(input),
+    auth: {
+        ability: ADMIN_USERS_ABILITIES.read
+    },
+    schemas: {
+        input: getAdminUserRequestSchema,
+        output: adminUserResponseSchema
+    },
+    handler: ({ input, deps })=>serviceOf(deps).getUser(input)
 });
-export const createAdminUserCommand = createCommand({
+const createAdminUserCommand = createCommand({
     method: 'createAdminUser',
-    auth: { ability: ADMIN_USERS_ABILITIES.create },
-    schemas: { input: createAdminUserRequestSchema, output: adminUserResponseSchema },
-    handler: ({ input, deps }) => serviceOf(deps).createUser(input),
+    auth: {
+        ability: ADMIN_USERS_ABILITIES.create
+    },
+    schemas: {
+        input: createAdminUserRequestSchema,
+        output: adminUserResponseSchema
+    },
+    handler: ({ input, deps })=>serviceOf(deps).createUser(input)
 });
-export const updateAdminUserCommand = createCommand({
+const updateAdminUserCommand = createCommand({
     method: 'updateAdminUser',
-    auth: { ability: ADMIN_USERS_ABILITIES.update },
-    schemas: { input: updateAdminUserRequestSchema, output: adminUserResponseSchema },
-    handler: ({ input, deps }) => serviceOf(deps).updateUser(input),
+    auth: {
+        ability: ADMIN_USERS_ABILITIES.update
+    },
+    schemas: {
+        input: updateAdminUserRequestSchema,
+        output: adminUserResponseSchema
+    },
+    handler: ({ input, deps })=>serviceOf(deps).updateUser(input)
 });
-export const setAdminUserPasswordCommand = createCommand({
+const setAdminUserPasswordCommand = createCommand({
     method: 'setAdminUserPassword',
-    auth: { ability: ADMIN_USERS_ABILITIES.changePassword },
-    schemas: { input: setAdminUserPasswordRequestSchema, output: adminUserResponseSchema },
-    handler: ({ input, deps }) => serviceOf(deps).setPassword(input),
+    auth: {
+        ability: ADMIN_USERS_ABILITIES.changePassword
+    },
+    schemas: {
+        input: setAdminUserPasswordRequestSchema,
+        output: adminUserResponseSchema
+    },
+    handler: ({ input, deps })=>serviceOf(deps).setPassword(input)
 });
-export const enableAdminUserCommand = createCommand({
+const enableAdminUserCommand = createCommand({
     method: 'enableAdminUser',
-    auth: { ability: ADMIN_USERS_ABILITIES.update },
-    schemas: { input: enableAdminUserRequestSchema, output: okResponseSchema },
-    handler: async ({ input, deps }) => {
-        await serviceOf(deps).enableUser(input);
-        return { ok: true };
+    auth: {
+        ability: ADMIN_USERS_ABILITIES.update
+    },
+    schemas: {
+        input: enableAdminUserRequestSchema,
+        output: okResponseSchema
     },
+    handler: async ({ input, deps })=>{
+        await serviceOf(deps).enableUser(input);
+        return {
+            ok: true
+        };
+    }
 });
-export const disableAdminUserCommand = createCommand({
+const disableAdminUserCommand = createCommand({
     method: 'disableAdminUser',
-    auth: { ability: ADMIN_USERS_ABILITIES.update },
-    schemas: { input: disableAdminUserRequestSchema, output: okResponseSchema },
-    handler: async ({ input, deps, actor }) => {
-        await serviceOf(deps).disableUser(actor, input);
-        return { ok: true };
+    auth: {
+        ability: ADMIN_USERS_ABILITIES.update
+    },
+    schemas: {
+        input: disableAdminUserRequestSchema,
+        output: okResponseSchema
     },
+    handler: async ({ input, deps, actor })=>{
+        await serviceOf(deps).disableUser(actor, input);
+        return {
+            ok: true
+        };
+    }
 });
-export const deleteAdminUserCommand = createCommand({
+const deleteAdminUserCommand = createCommand({
     method: 'deleteAdminUser',
-    auth: { ability: ADMIN_USERS_ABILITIES.delete },
-    schemas: { input: deleteAdminUserRequestSchema, output: okResponseSchema },
-    handler: async ({ input, deps, actor }) => {
-        await serviceOf(deps).deleteUser(actor, input);
-        return { ok: true };
+    auth: {
+        ability: ADMIN_USERS_ABILITIES["delete"]
     },
+    schemas: {
+        input: deleteAdminUserRequestSchema,
+        output: okResponseSchema
+    },
+    handler: async ({ input, deps, actor })=>{
+        await serviceOf(deps).deleteUser(actor, input);
+        return {
+            ok: true
+        };
+    }
 });
+export { createAdminUserCommand, deleteAdminUserCommand, disableAdminUserCommand, enableAdminUserCommand, getAdminUserCommand, listAdminUsersCommand, setAdminUserPasswordCommand, updateAdminUserCommand };

package/dist/modules/admin-users/components/create.d.ts

@@ -0,0 +1,8 @@
+import type { AdminUserResponse } from '../index.js';
+interface CreateAdminUserProps {
+    onClose?: () => void;
+    /** Called on successful create with the new user so the parent can navigate. */
+    onSuccess?: (user: AdminUserResponse) => void;
+}
+export declare function CreateAdminUser({ onClose, onSuccess }: CreateAdminUserProps): import("react").JSX.Element;
+export {};