@jini-ai/user-management 0.2.0

package/dist/react/index.d.ts

@@ -0,0 +1,18 @@
+export type * from './models.js';
+export type * from './ports.js';
+export { Login } from './auth/Login.js';
+export type { LoginProps } from './auth/Login.js';
+export { useLogin } from './auth/hooks/use-login.hooks.js';
+export type { LoginController, LoginHookProps, LoginOptions } from './auth/hooks/use-login.hooks.js';
+export { Users, UserManagePanel } from './users/Users.js';
+export type { UsersProps, GrantOption, GrantSelectController, UserManageController, UserManagePanelProps, UserRowActionsController, UserRowProps, UsersTableProps } from './users/Users.js';
+export { useUsers } from './users/hooks/use-users.hooks.js';
+export type { UsersController, UsersDependencies, UsersOptions } from './users/hooks/use-users.hooks.js';
+export { useResetPasswordFields } from './users/hooks/use-reset-password-fields.hooks.js';
+export type { ResetPasswordFieldsInput, ResetPasswordFieldsController } from './users/hooks/use-reset-password-fields.hooks.js';
+export { Members } from './members/Members.js';
+export type { MembersProps } from './members/Members.js';
+export { useMembers } from './members/hooks/use-members.hooks.js';
+export type { MembersController, MembersDependencies, MembersOptions } from './members/hooks/use-members.hooks.js';
+export { describeIdentityError } from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.js

@@ -0,0 +1,9 @@
+export { Login } from './auth/Login.js';
+export { useLogin } from './auth/hooks/use-login.hooks.js';
+export { Users, UserManagePanel } from './users/Users.js';
+export { useUsers } from './users/hooks/use-users.hooks.js';
+export { useResetPasswordFields } from './users/hooks/use-reset-password-fields.hooks.js';
+export { Members } from './members/Members.js';
+export { useMembers } from './members/hooks/use-members.hooks.js';
+export { describeIdentityError } from './errors.js';
+//# sourceMappingURL=index.js.map

package/dist/react/members/Members.d.ts

@@ -0,0 +1,6 @@
+import { useMembers, type MembersDependencies, type MembersOptions } from "./hooks/use-members.hooks.js";
+export interface MembersProps extends MembersDependencies, MembersOptions {
+    useMembersHook?: typeof useMembers | undefined;
+}
+export declare function Members({ useMembersHook, port, translate: injectedTranslate, refresh }: MembersProps): import("react").JSX.Element;
+//# sourceMappingURL=Members.d.ts.map

package/dist/react/members/Members.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment } from "react";
+import { RowMenu, ConfirmDialog } from "@jini-ai/admin/react";
+import { agentHandle } from "@jini-ai/agentic";
+import { formatTimestamp } from "@jini-ai/ui/panel-kit";
+import { buildAgentListHandles } from "@jini-ai/ui/panel-kit";
+import { memberRowMenuItems } from "./rules.js";
+import { useMembers } from "./hooks/use-members.hooks.js";
+function MemberDetailPanel({ memberId, detailLoadingId, detailError, detail, t }) {
+    if (detailLoadingId === memberId)
+        return _jsx("div", { className: "notice", children: t("Loading detail…") });
+    if (detailError)
+        return _jsx("div", { className: "notice error", children: detailError });
+    if (!detail)
+        return null;
+    return (_jsxs("dl", { className: "member-detail", children: [_jsx("dt", { children: t("ID") }), _jsx("dd", { children: detail.id }), _jsx("dt", { children: t("Email verified") }), _jsx("dd", { children: detail.emailVerifiedAt ?? t("not verified") }), _jsx("dt", { children: t("Updated") }), _jsx("dd", { children: detail.updatedAt }), _jsx("dt", { children: t("Version") }), _jsx("dd", { children: detail.version })] }));
+}
+function MemberRow({ member, rowState, isExpanded, detail, detailError, detailLoadingId, onToggleDetail, onResendSignInLink, setConfirmingDisable, agentBase, t, translate, }) {
+    return (_jsxs(Fragment, { children: [_jsxs("tr", { children: [_jsx("td", { children: _jsx("button", { type: "button", className: "link-button", onClick: () => void onToggleDetail(member), "aria-expanded": isExpanded, ...agentHandle({ handle: `${agentBase}-toggle-detail` }, { role: "button", label: t(`Expand or collapse ${member.email}'s detail panel`) }), children: member.email }) }), _jsx("td", { children: member.name ?? t("—") }), _jsx("td", { children: _jsx("span", { className: `status status-${member.status}`, children: t(member.status) }) }), _jsx("td", { children: formatTimestamp({ iso: member.createdAt }) }), _jsxs("td", { children: [_jsx(RowMenu, { triggerLabel: `${t("Actions for member")} "${member.email}"`, agentHandle: `${agentBase}-menu`, items: memberRowMenuItems({
+                                    member,
+                                    rs: rowState,
+                                    handlers: {
+                                        onResendSignInLink: (m) => void onResendSignInLink(m),
+                                        onRequestDisable: setConfirmingDisable,
+                                    },
+                                    translate,
+                                }) }), rowState.error ? (_jsx("div", { className: "notice error", role: "alert", children: rowState.error })) : null, rowState.notice ? _jsx("div", { className: "notice", children: rowState.notice }) : null] })] }), isExpanded ? (_jsx("tr", { children: _jsx("td", { colSpan: 5, children: _jsx(MemberDetailPanel, { memberId: member.id, detailLoadingId: detailLoadingId, detailError: detailError, detail: detail, t: t }) }) })) : null] }, member.id));
+}
+export function Members({ useMembersHook = useMembers, port, translate: injectedTranslate, refresh }) {
+    const { members, error, stateFor, onResendSignInLink, expandedId, detailById, detailError, detailLoadingId, onToggleDetail, confirmingDisable, setConfirmingDisable, confirmDisable, t, translate, } = useMembersHook({ port, translate: injectedTranslate }, { refresh });
+    if (error)
+        return _jsx("div", { className: "notice error", children: error });
+    if (!members)
+        return _jsx("div", { className: "notice", children: t("Loading members…") });
+    const memberMenuBases = buildAgentListHandles({ prefix: "members-row", ids: members.map((member) => member.id) });
+    return (_jsxs("div", { className: "page", children: [_jsx("div", { className: "page-header", children: _jsxs("div", { className: "page-header-text", children: [_jsx("p", { className: "page-kicker", children: t("People") }), _jsx("h1", { className: "page-title", children: t("Members") }), _jsx("p", { className: "page-description", children: t("People who have registered an account — review status, resend a sign-in link, or disable access.") })] }) }), members.length === 0 ? (_jsx("div", { className: "card", children: _jsxs("div", { className: "empty-state", children: [_jsx("p", { children: t("No members yet.") }), _jsx("p", { className: "page-description", children: t("Registered members will show up here.") })] }) })) : (_jsx("div", { className: "table-scroll", children: _jsxs("table", { className: "list-table", children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { children: t("Email") }), _jsx("th", { children: t("Name") }), _jsx("th", { children: t("Status") }), _jsx("th", { children: t("Created") }), _jsx("th", { children: t("Actions") })] }) }), _jsx("tbody", { children: members.map((member, index) => (_jsx(MemberRow, { member: member, rowState: stateFor({ id: member.id }), isExpanded: expandedId === member.id, detail: detailById[member.id], detailError: detailError, detailLoadingId: detailLoadingId, onToggleDetail: onToggleDetail, onResendSignInLink: onResendSignInLink, setConfirmingDisable: setConfirmingDisable, agentBase: memberMenuBases[index], t: t, translate: translate }, member.id))) })] }) })), _jsx(ConfirmDialog, { cancelLabel: t("Cancel"), open: confirmingDisable !== null, agentHandle: "members-disable", title: t("Disable this member?"), body: confirmingDisable ? (_jsxs("p", { children: [t("Disable"), " \"", confirmingDisable.email, "\"? ", t("They will no longer be able to sign in.")] })) : null, confirmLabel: t("Disable"), tone: "warning", pending: confirmingDisable !== null && stateFor({ id: confirmingDisable.id }).disabling, onConfirm: confirmDisable, onCancel: () => setConfirmingDisable(null) })] }));
+}
+//# sourceMappingURL=Members.js.map

package/dist/react/members/hooks/use-members.hooks.d.ts

@@ -0,0 +1,32 @@
+import { type Dispatch, type SetStateAction } from "react";
+import type { AdminMember } from "../../models.js";
+import { type RowActionState } from "../rules.js";
+import type { MembersPort, IdentityRefreshPort } from "../../ports.js";
+import type { Translate } from "@jini-ai/ui/panel-kit";
+export interface MembersDependencies {
+    port: MembersPort;
+    translate: Translate;
+}
+export interface MembersController {
+    members: AdminMember[] | null;
+    error: string | null;
+    stateFor: (required: {
+        id: string;
+    }) => RowActionState;
+    onResendSignInLink: (member: AdminMember) => Promise<void>;
+    expandedId: string | null;
+    detailById: Record<string, AdminMember>;
+    detailError: string | null;
+    detailLoadingId: string | null;
+    onToggleDetail: (member: AdminMember) => Promise<void>;
+    confirmingDisable: AdminMember | null;
+    setConfirmingDisable: Dispatch<SetStateAction<AdminMember | null>>;
+    confirmDisable: () => Promise<void>;
+    t: Translate;
+    translate: Translate;
+}
+export interface MembersOptions {
+    refresh?: IdentityRefreshPort | undefined;
+}
+export declare function useMembers({ port, translate }: MembersDependencies, { refresh }?: MembersOptions): MembersController;
+//# sourceMappingURL=use-members.hooks.d.ts.map

package/dist/react/members/hooks/use-members.hooks.js

@@ -0,0 +1,120 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { describeApiError as describeFeatureError, emptyRowState } from "../rules.js";
+import { useSettlementGeneration } from "@jini-ai/ui/panel-kit";
+export function useMembers({ port, translate }, { refresh } = {}) {
+    const describeApiError = (error, fallback) => describeFeatureError({ error, fallback, translate });
+    const t = translate;
+    const boundT = translate;
+    const [members, setMembers] = useState(null);
+    const [error, setError] = useState(null);
+    const [rowState, setRowState] = useState({});
+    const [expandedId, setExpandedId] = useState(null);
+    const [detailById, setDetailById] = useState({});
+    const [detailError, setDetailError] = useState(null);
+    const [detailLoadingId, setDetailLoadingId] = useState(null);
+    const [confirmingDisable, setConfirmingDisable] = useState(null);
+    const settlement = useSettlementGeneration();
+    const expandedIdRef = useRef(null);
+    const detailSettlement = useSettlementGeneration();
+    const load = useCallback(() => {
+        const generation = settlement.next();
+        port
+            .listMembers({})
+            .then((r) => {
+            if (!settlement.isCurrent({ generation }))
+                return;
+            setMembers(r.members);
+            setError(null);
+        })
+            .catch((e) => {
+            if (!settlement.isCurrent({ generation }))
+                return;
+            setError(e instanceof Error ? e.message : t("failed to load members"));
+        });
+    }, [port, settlement, translate]);
+    useEffect(() => {
+        load();
+    }, [load]);
+    useEffect(() => refresh?.subscribe({ onRefresh: load }), [refresh, load]);
+    function stateFor({ id }) {
+        return rowState[id] ?? emptyRowState({});
+    }
+    function patchRowState(id, patch) {
+        setRowState((current) => ({ ...current, [id]: { ...emptyRowState({}), ...current[id], ...patch } }));
+    }
+    async function onDisable(member) {
+        if (stateFor({ id: member.id }).disabling)
+            return;
+        patchRowState(member.id, { disabling: true, error: null, notice: null });
+        try {
+            const result = await port.disableMember({ id: member.id });
+            setMembers((current) => (current ? current.map((m) => (m.id === member.id ? result.member : m)) : current));
+            patchRowState(member.id, { disabling: false, notice: t("Member disabled.") });
+        }
+        catch (e) {
+            patchRowState(member.id, { disabling: false, error: describeApiError(e, t("Failed to disable member.")) });
+        }
+    }
+    async function onResendSignInLink(member) {
+        if (stateFor({ id: member.id }).resending)
+            return;
+        patchRowState(member.id, { resending: true, error: null, notice: null });
+        try {
+            await port.requestMemberMagicLink({ email: member.email });
+            patchRowState(member.id, { resending: false, notice: t("Sign-in link sent.") });
+        }
+        catch (e) {
+            patchRowState(member.id, { resending: false, error: describeApiError(e, t("Failed to send sign-in link.")) });
+        }
+    }
+    async function confirmDisable() {
+        if (!confirmingDisable)
+            return;
+        await onDisable(confirmingDisable);
+        setConfirmingDisable(null);
+    }
+    async function onToggleDetail(member) {
+        if (expandedIdRef.current === member.id) {
+            expandedIdRef.current = null;
+            setExpandedId(null);
+            return;
+        }
+        expandedIdRef.current = member.id;
+        setExpandedId(member.id);
+        setDetailError(null);
+        if (detailById[member.id])
+            return;
+        setDetailLoadingId(member.id);
+        const generation = detailSettlement.next();
+        try {
+            const result = await port.getMember({ id: member.id });
+            setDetailById((current) => ({ ...current, [member.id]: result.member }));
+        }
+        catch (e) {
+            if (detailSettlement.isCurrent({ generation }) && expandedIdRef.current === member.id) {
+                setDetailError(describeApiError(e, t("Failed to load member detail.")));
+            }
+        }
+        finally {
+            if (detailSettlement.isCurrent({ generation }))
+                setDetailLoadingId(null);
+        }
+    }
+    return {
+        members,
+        error,
+        stateFor,
+        onResendSignInLink,
+        expandedId,
+        detailById,
+        detailError,
+        detailLoadingId,
+        onToggleDetail,
+        confirmingDisable,
+        setConfirmingDisable,
+        confirmDisable,
+        t: boundT,
+        translate,
+    };
+}
+//# sourceMappingURL=use-members.hooks.js.map

package/dist/react/members/rules.d.ts

@@ -0,0 +1,26 @@
+import type { AdminMember } from "../models.js";
+import type { Translate } from "@jini-ai/ui/panel-kit";
+import type { RowMenuItem } from "@jini-ai/admin/react";
+export interface RowActionState {
+    disabling: boolean;
+    resending: boolean;
+    error: string | null;
+    notice: string | null;
+}
+export declare function emptyRowState(_required: Record<string, never>): RowActionState;
+export declare function describeApiError({ error, fallback, translate }: {
+    error: unknown;
+    fallback: string;
+    translate: Translate;
+}): string;
+export interface MemberRowMenuHandlers {
+    onResendSignInLink: (member: AdminMember) => void;
+    onRequestDisable: (member: AdminMember) => void;
+}
+export declare function memberRowMenuItems({ member, rs, handlers, translate }: {
+    member: AdminMember;
+    rs: RowActionState;
+    handlers: MemberRowMenuHandlers;
+    translate: Translate;
+}): RowMenuItem[];
+//# sourceMappingURL=rules.d.ts.map

package/dist/react/members/rules.js

@@ -0,0 +1,35 @@
+import { describeIdentityError } from "../errors.js";
+const STATIC_ERROR_MESSAGES = { FORBIDDEN: "You do not have permission to do that." };
+export function emptyRowState(_required) {
+    return { disabling: false, resending: false, error: null, notice: null };
+}
+export function describeApiError({ error, fallback, translate }) {
+    return describeIdentityError({ error, fallback, translate }, { messages: STATIC_ERROR_MESSAGES });
+}
+export function memberRowMenuItems({ member, rs, handlers, translate }) {
+    const items = [
+        {
+            key: "resend",
+            label: translate("Resend sign-in link"),
+            onSelect: () => {
+                if (rs.resending)
+                    return;
+                handlers.onResendSignInLink(member);
+            },
+        },
+    ];
+    if (member.status !== "disabled") {
+        items.push({
+            key: "disable",
+            label: translate("Disable"),
+            tone: "warning",
+            onSelect: () => {
+                if (rs.disabling)
+                    return;
+                handlers.onRequestDisable(member);
+            },
+        });
+    }
+    return items;
+}
+//# sourceMappingURL=rules.js.map

package/dist/react/models.d.ts

@@ -0,0 +1,50 @@
+/** Browser-facing administration DTOs; no transport or server imports. */
+export interface AdminUser {
+    id: string;
+    username: string;
+}
+export interface AdminIdentityUser {
+    principalId: string;
+    workspaceId: string;
+    username: string;
+    email?: string | undefined;
+    status: "active" | "disabled";
+    createdAt: string;
+    lastLoginAt?: string | undefined;
+    roleIds: string[];
+    policyIds: string[];
+}
+export interface AdminRole {
+    id: string;
+    workspaceId: string;
+    name: string;
+    isBuiltin: boolean;
+}
+export interface AdminPolicy {
+    id: string;
+    workspaceId: string;
+    name: string;
+    description?: string | undefined;
+    isBuiltin: boolean;
+    isFrozen: boolean;
+}
+export interface AdminPolicyPermission {
+    id: string;
+    workspaceId: string;
+    policyId: string;
+    permission: string;
+    resourceType?: string | null | undefined;
+    constraintJson?: string | null | undefined;
+}
+export interface AdminMember {
+    id: string;
+    workspaceId: string;
+    email: string;
+    name?: string | undefined;
+    status: "pending" | "active" | "disabled";
+    emailVerifiedAt?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+    version: number;
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/react/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.js.map

package/dist/react/ports.d.ts

@@ -0,0 +1,157 @@
+import type { AdminUser, AdminIdentityUser, AdminRole, AdminPolicy, AdminPolicyPermission, AdminMember } from "./models.js";
+export interface LoginPort {
+    login(credentials: {
+        username: string;
+        password: string;
+    }): Promise<{
+        user: AdminUser;
+    }>;
+}
+export interface UsersPort {
+    listUsers(required: Record<string, never>): Promise<{
+        users: AdminIdentityUser[];
+    }>;
+    me(required: Record<string, never>): Promise<{
+        user: {
+            id: string;
+        };
+        canManageUserTrash: boolean;
+    }>;
+    listRoles(required: Record<string, never>): Promise<{
+        roles: AdminRole[];
+    }>;
+    listPolicies(required: Record<string, never>): Promise<{
+        policies: AdminPolicy[];
+    }>;
+    createUser(input: {
+        username: string;
+        password: string;
+    }, options?: {
+        email?: string | undefined;
+    }): Promise<{
+        user: AdminIdentityUser;
+    }>;
+    updateUser(target: {
+        principalId: string;
+    }, options?: {
+        email?: string | undefined;
+    }): Promise<{
+        user: AdminIdentityUser;
+    }>;
+    disableUser(required: {
+        principalId: string;
+    }): Promise<{
+        user: AdminIdentityUser;
+    }>;
+    enableUser(required: {
+        principalId: string;
+    }): Promise<{
+        user: AdminIdentityUser;
+    }>;
+    resetUserPassword(input: {
+        principalId: string;
+        password: string;
+    }): Promise<void>;
+    assignRole(input: {
+        principalId: string;
+        roleId: string;
+    }): Promise<{
+        assignment: unknown;
+    }>;
+    attachPolicy(input: {
+        principalId: string;
+        policyId: string;
+    }): Promise<{
+        attachment: unknown;
+    }>;
+    deleteUser(required: {
+        principalId: string;
+    }): Promise<void>;
+}
+export interface RolesPort {
+    listRoles(required: Record<string, never>): Promise<{
+        roles: AdminRole[];
+    }>;
+    listPolicies(required: Record<string, never>): Promise<{
+        policies: AdminPolicy[];
+    }>;
+    createRole(required: {
+        name: string;
+    }): Promise<{
+        role: AdminRole;
+    }>;
+    updateRole(input: {
+        roleId: string;
+        name: string;
+    }): Promise<{
+        role: AdminRole;
+    }>;
+    deleteRole(required: {
+        roleId: string;
+    }): Promise<void>;
+    createPolicy(input: {
+        name: string;
+    }, options?: {
+        description?: string | undefined;
+    }): Promise<{
+        policy: AdminPolicy;
+    }>;
+    updatePolicy(target: {
+        policyId: string;
+    }, options?: {
+        name?: string | undefined;
+        description?: string | undefined;
+    }): Promise<{
+        policy: AdminPolicy;
+    }>;
+    deletePolicy(required: {
+        policyId: string;
+    }): Promise<void>;
+    writePolicyPermission(input: {
+        policyId: string;
+        permission: string;
+    }, options?: {
+        resourceType?: string | undefined;
+    }): Promise<{
+        policyPermission: unknown;
+    }>;
+    listPolicyPermissions(required: {
+        policyId: string;
+    }): Promise<{
+        policyPermissions: AdminPolicyPermission[];
+    }>;
+    removePolicyPermission(input: {
+        policyId: string;
+        policyPermissionId: string;
+    }): Promise<void>;
+}
+export interface MembersPort {
+    listMembers(required: Record<string, never>): Promise<{
+        members: AdminMember[];
+    }>;
+    getMember(required: {
+        id: string;
+    }): Promise<{
+        member: AdminMember;
+    }>;
+    disableMember(required: {
+        id: string;
+    }): Promise<{
+        member: AdminMember;
+    }>;
+    requestMemberMagicLink(input: {
+        email: string;
+    }): Promise<{
+        delivered: true;
+    }>;
+}
+/** Compose once per host/workspace. Screens never choose an HTTP transport. */
+export interface IdentityAdminPort extends LoginPort, UsersPort, RolesPort, MembersPort {
+}
+/** The host owns event topics; subscribe binds only the current members scope. */
+export interface IdentityRefreshPort {
+    subscribe(required: {
+        onRefresh: () => void;
+    }): () => void;
+}
+//# sourceMappingURL=ports.d.ts.map

package/dist/react/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/react/roles/Roles.d.ts

@@ -0,0 +1,100 @@
+import type { Translate } from "@jini-ai/ui/panel-kit";
+import { type FormEvent } from "react";
+import type { AdminPolicy, AdminPolicyPermission, AdminRole } from "../models.js";
+import { useRoles, type RolesDependencies, type PendingPermissionRemove } from "./hooks/use-roles.hooks.js";
+import { type RolesTabId } from "./Roles.hooks.js";
+export interface RolesProps extends RolesDependencies {
+    onTabChange: (required: {
+        tabId: RolesTabId;
+    }) => void;
+    usersHref: string;
+    tabId?: string | null | undefined;
+    useRolesHook?: typeof useRoles | undefined;
+}
+export interface RoleCreateFormController {
+    name: string;
+    setName: (name: string) => void;
+    saving: boolean;
+    error: string | null;
+    submit: (e: FormEvent) => Promise<void>;
+}
+export interface RoleRowController {
+    editingId: string | null;
+    setEditingId: (roleId: string | null) => void;
+    draftName: string;
+    setDraftName: (name: string) => void;
+    startRename: (role: AdminRole) => void;
+    saveRename: (required: {
+        roleId: string;
+    }) => Promise<void>;
+    savingId: string | null;
+    requestDelete: (role: AdminRole | null) => void;
+}
+export interface RolesSectionProps {
+    roles: AdminRole[];
+    create: RoleCreateFormController;
+    row: RoleRowController;
+    t: (key: string) => string;
+    translate: Translate;
+}
+export declare function RolesSection({ roles, create, row, t, translate }: RolesSectionProps): import("react").JSX.Element;
+export interface PolicyRowController {
+    editingId: string | null;
+    setEditingId: (policyId: string | null) => void;
+    draftName: string;
+    setDraftName: (name: string) => void;
+    draftDescription: string;
+    setDraftDescription: (description: string) => void;
+    startRename: (policy: AdminPolicy) => void;
+    saveRename: (required: {
+        policyId: string;
+    }) => Promise<void>;
+    savingId: string | null;
+    requestDelete: (policy: AdminPolicy | null) => void;
+}
+export interface PolicyPermissionController {
+    openForPolicyId: string | null;
+    permission: string;
+    setPermission: (permission: string) => void;
+    resourceType: string;
+    setResourceType: (resourceType: string) => void;
+    toggleForm: (required: {
+        policyId: string;
+    }) => void;
+    write: (required: {
+        policyId: string;
+    }) => Promise<void>;
+    rows: AdminPolicyPermission[];
+    loading: boolean;
+    removingId: string | null;
+    requestRemove: (target: PendingPermissionRemove) => void;
+}
+export interface PolicyRowProps {
+    policy: AdminPolicy;
+    row: PolicyRowController;
+    permission: PolicyPermissionController;
+    agentBase: string;
+    t: (key: string) => string;
+    translate: Translate;
+}
+export declare function PolicyRow({ policy, row, permission, agentBase, t, translate }: PolicyRowProps): import("react").JSX.Element;
+export interface PolicyCreateFormController {
+    name: string;
+    setName: (name: string) => void;
+    description: string;
+    setDescription: (description: string) => void;
+    saving: boolean;
+    error: string | null;
+    submit: (e: FormEvent) => Promise<void>;
+}
+export interface PoliciesSectionProps {
+    policies: AdminPolicy[];
+    create: PolicyCreateFormController;
+    row: PolicyRowController;
+    permission: PolicyPermissionController;
+    t: (key: string) => string;
+    translate: Translate;
+}
+export declare function PoliciesSection({ policies, create, row, permission, t, translate }: PoliciesSectionProps): import("react").JSX.Element;
+export declare function Roles({ tabId, useRolesHook, port, translate: injectedTranslate, queryScope, onTabChange, usersHref }: RolesProps): import("react").JSX.Element;
+//# sourceMappingURL=Roles.d.ts.map

package/dist/react/roles/Roles.hooks.d.ts

@@ -0,0 +1,17 @@
+import type { TabBarTab } from "@jini-ai/ui/tab-strip";
+import type { Translate } from "@jini-ai/ui/panel-kit";
+export declare function RolesIcon({ size }: {
+    size?: number;
+}): import("react").JSX.Element;
+export declare function PoliciesIcon({ size }: {
+    size?: number;
+}): import("react").JSX.Element;
+export declare const ROLES_TAB_IDS: readonly ["roles", "policies"];
+export type RolesTabId = (typeof ROLES_TAB_IDS)[number];
+export declare function resolveRolesTabId({ tabId }: {
+    tabId: string | null | undefined;
+}): RolesTabId;
+export declare function resolveRolesTabs({ translate: t }: {
+    translate: Translate;
+}): TabBarTab[];
+//# sourceMappingURL=Roles.hooks.d.ts.map

package/dist/react/roles/Roles.hooks.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { resolveActiveTabId } from "@jini-ai/ui/panel-kit";
+const LINE_ICON = {
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    strokeWidth: 1.5,
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    "aria-hidden": true,
+};
+export function RolesIcon({ size = 16 }) {
+    return (_jsxs("svg", { ...LINE_ICON, width: size, height: size, children: [_jsx("circle", { cx: "12", cy: "8", r: "3.5" }), _jsx("path", { d: "M5 20c0-3.3 3.1-6 7-6s7 2.7 7 6" })] }));
+}
+export function PoliciesIcon({ size = 16 }) {
+    return (_jsxs("svg", { ...LINE_ICON, width: size, height: size, children: [_jsx("path", { d: "M12 3l7 2.5v6c0 4-3 7.4-7 8.5-4-1.1-7-4.5-7-8.5v-6z" }), _jsx("path", { d: "M9.5 11.5h5M9.5 14.5h3" })] }));
+}
+export const ROLES_TAB_IDS = ["roles", "policies"];
+export function resolveRolesTabId({ tabId }) {
+    return resolveActiveTabId({ tabId, validIds: ROLES_TAB_IDS, defaultId: "roles" });
+}
+export function resolveRolesTabs({ translate: t }) {
+    return [
+        {
+            id: "roles",
+            label: t("Roles"),
+            icon: _jsx(RolesIcon, {}),
+            handle: "roles-tab-roles",
+            handleLabel: t("Switch to the Roles tab — list, create, rename and delete the roles a person can be assigned"),
+        },
+        {
+            id: "policies",
+            label: t("Policies"),
+            icon: _jsx(PoliciesIcon, {}),
+            handle: "roles-tab-policies",
+            handleLabel: t("Switch to the Policies tab — list and create policies, and add or remove the individual permissions on each one"),
+        },
+    ];
+}
+//# sourceMappingURL=Roles.hooks.js.map