@abpjs/identity-pro 0.7.2

package/dist/index.js

@@ -0,0 +1,1910 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClaimModal: () => ClaimModal,
+  ClaimsComponent: () => ClaimsComponent,
+  IDENTITY_POLICIES: () => IDENTITY_POLICIES,
+  IDENTITY_ROUTES: () => IDENTITY_ROUTES,
+  IDENTITY_ROUTE_PATHS: () => IDENTITY_ROUTE_PATHS,
+  Identity: () => Identity,
+  IdentityService: () => IdentityService,
+  RolesComponent: () => RolesComponent,
+  UsersComponent: () => UsersComponent,
+  useClaims: () => useClaims,
+  useIdentity: () => useIdentity,
+  useRoles: () => useRoles,
+  useUsers: () => useUsers
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/models/identity.ts
+var Identity;
+((Identity2) => {
+  let ClaimValueType;
+  ((ClaimValueType2) => {
+    ClaimValueType2[ClaimValueType2["String"] = 0] = "String";
+    ClaimValueType2[ClaimValueType2["Int"] = 1] = "Int";
+    ClaimValueType2[ClaimValueType2["Boolean"] = 2] = "Boolean";
+    ClaimValueType2[ClaimValueType2["DateTime"] = 3] = "DateTime";
+  })(ClaimValueType = Identity2.ClaimValueType || (Identity2.ClaimValueType = {}));
+})(Identity || (Identity = {}));
+
+// src/services/identity.service.ts
+var IdentityService = class {
+  constructor(rest) {
+    this.rest = rest;
+  }
+  // ========================
+  // Role Operations
+  // ========================
+  /**
+   * Get all roles with optional pagination/filtering (v0.9.0)
+   * @param params - Optional query parameters for pagination and filtering
+   * @returns Promise with paginated role response
+   */
+  getRoles(params = {}) {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/identity/roles",
+      params
+    });
+  }
+  /**
+   * Get a role by ID
+   * @param id - The role ID
+   * @returns Promise with the role item
+   */
+  getRoleById(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/identity/roles/${id}`
+    });
+  }
+  /**
+   * Delete a role
+   * @param id - The role ID to delete
+   * @returns Promise with the deleted role
+   */
+  deleteRole(id) {
+    return this.rest.request({
+      method: "DELETE",
+      url: `/api/identity/roles/${id}`
+    });
+  }
+  /**
+   * Create a new role
+   * @param body - The role data to create
+   * @returns Promise with the created role
+   */
+  createRole(body) {
+    return this.rest.request({
+      method: "POST",
+      url: "/api/identity/roles",
+      body
+    });
+  }
+  /**
+   * Update an existing role
+   * @param id - The role ID to update
+   * @param body - The updated role data
+   * @returns Promise with the updated role
+   */
+  updateRole(id, body) {
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/identity/roles/${id}`,
+      body
+    });
+  }
+  // ========================
+  // User Operations
+  // ========================
+  /**
+   * Get users with pagination and filtering
+   * @param params - Query parameters for pagination and filtering
+   * @returns Promise with paginated user response
+   */
+  getUsers(params = {}) {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/identity/users",
+      params
+    });
+  }
+  /**
+   * Get a user by ID
+   * @param id - The user ID
+   * @returns Promise with the user item
+   */
+  getUserById(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/identity/users/${id}`
+    });
+  }
+  /**
+   * Get roles assigned to a user
+   * @param id - The user ID
+   * @returns Promise with the user's roles
+   */
+  getUserRoles(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/identity/users/${id}/roles`
+    });
+  }
+  /**
+   * Delete a user
+   * @param id - The user ID to delete
+   * @returns Promise resolving when complete
+   */
+  deleteUser(id) {
+    return this.rest.request({
+      method: "DELETE",
+      url: `/api/identity/users/${id}`
+    });
+  }
+  /**
+   * Create a new user
+   * @param body - The user data to create
+   * @returns Promise with the created user
+   */
+  createUser(body) {
+    return this.rest.request({
+      method: "POST",
+      url: "/api/identity/users",
+      body
+    });
+  }
+  /**
+   * Update an existing user
+   * @param id - The user ID to update
+   * @param body - The updated user data
+   * @returns Promise with the updated user
+   */
+  updateUser(id, body) {
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/identity/users/${id}`,
+      body
+    });
+  }
+  // ========================
+  // Pro: Claim Type Operations
+  // ========================
+  /**
+   * Get all claim type names for dropdowns
+   * Pro feature since 0.7.2
+   * @returns Promise with claim type names
+   */
+  getClaimTypeNames() {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/identity/claim-types/all"
+    });
+  }
+  /**
+   * Get claim types with pagination
+   * Pro feature since 0.7.2
+   * @param params - Query parameters for pagination and filtering
+   * @returns Promise with paginated claim types response
+   */
+  getClaimTypes(params = {}) {
+    return this.rest.request({
+      method: "GET",
+      url: "/api/identity/claim-types",
+      params
+    });
+  }
+  /**
+   * Get a claim type by ID
+   * Pro feature since 0.7.2
+   * @param id - The claim type ID
+   * @returns Promise with the claim type
+   */
+  getClaimTypeById(id) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/identity/claim-types/${id}`
+    });
+  }
+  /**
+   * Create a new claim type
+   * Pro feature since 0.7.2
+   * @param body - The claim type data
+   * @returns Promise with the created claim type
+   */
+  createClaimType(body) {
+    return this.rest.request({
+      method: "POST",
+      url: "/api/identity/claim-types",
+      body
+    });
+  }
+  /**
+   * Update an existing claim type
+   * Pro feature since 0.7.2
+   * @param body - The claim type data (must include id)
+   * @returns Promise with the updated claim type
+   */
+  updateClaimType(body) {
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/identity/claim-types/${body.id}`,
+      body
+    });
+  }
+  /**
+   * Delete a claim type
+   * Pro feature since 0.7.2
+   * @param id - The claim type ID to delete
+   * @returns Promise resolving when complete
+   */
+  deleteClaimType(id) {
+    return this.rest.request({
+      method: "DELETE",
+      url: `/api/identity/claim-types/${id}`
+    });
+  }
+  // ========================
+  // Pro: User/Role Claims
+  // ========================
+  /**
+   * Get claims for a user or role
+   * Pro feature since 0.7.2
+   * @param body - Object with id and type ('users' | 'roles')
+   * @returns Promise with claim requests
+   */
+  getClaims(body) {
+    return this.rest.request({
+      method: "GET",
+      url: `/api/identity/${body.type}/${body.id}/claims`
+    });
+  }
+  /**
+   * Update claims for a user or role
+   * Pro feature since 0.7.2
+   * @param body - Object with id, type, and claims array
+   * @returns Promise resolving when complete
+   */
+  updateClaims(body) {
+    return this.rest.request({
+      method: "PUT",
+      url: `/api/identity/${body.type}/${body.id}/claims`,
+      body: body.claims
+    });
+  }
+};
+
+// src/hooks/useRoles.ts
+var import_react = require("react");
+var import_core = require("@abpjs/core");
+function useRoles() {
+  const restService = (0, import_core.useRestService)();
+  const service = (0, import_react.useMemo)(() => new IdentityService(restService), [restService]);
+  const [roles, setRoles] = (0, import_react.useState)([]);
+  const [totalCount, setTotalCount] = (0, import_react.useState)(0);
+  const [selectedRole, setSelectedRole] = (0, import_react.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [sortKey, setSortKey] = (0, import_react.useState)("name");
+  const [sortOrder, setSortOrder] = (0, import_react.useState)("");
+  const fetchRoles = (0, import_react.useCallback)(async (params) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await service.getRoles(params);
+      setRoles(response.items || []);
+      setTotalCount(response.totalCount || 0);
+      setIsLoading(false);
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch roles";
+      setError(errorMessage);
+      setIsLoading(false);
+      return { success: false, error: errorMessage };
+    }
+  }, [service]);
+  const getRoleById = (0, import_react.useCallback)(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const role = await service.getRoleById(id);
+        setSelectedRole(role);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch role";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const createRole = (0, import_react.useCallback)(
+    async (role) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.createRole(role);
+        await fetchRoles();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create role";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchRoles]
+  );
+  const updateRole = (0, import_react.useCallback)(
+    async (id, role) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateRole(id, role);
+        await fetchRoles();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update role";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchRoles]
+  );
+  const deleteRole = (0, import_react.useCallback)(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.deleteRole(id);
+        await fetchRoles();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete role";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchRoles]
+  );
+  const reset = (0, import_react.useCallback)(() => {
+    setRoles([]);
+    setTotalCount(0);
+    setSelectedRole(null);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+  return {
+    roles,
+    totalCount,
+    selectedRole,
+    isLoading,
+    error,
+    sortKey,
+    sortOrder,
+    fetchRoles,
+    getRoleById,
+    createRole,
+    updateRole,
+    deleteRole,
+    setSelectedRole,
+    setSortKey,
+    setSortOrder,
+    reset
+  };
+}
+
+// src/hooks/useUsers.ts
+var import_react2 = require("react");
+var import_core2 = require("@abpjs/core");
+var DEFAULT_PAGE_QUERY = {
+  sorting: "userName",
+  skipCount: 0,
+  maxResultCount: 10
+};
+function useUsers() {
+  const restService = (0, import_core2.useRestService)();
+  const service = (0, import_react2.useMemo)(() => new IdentityService(restService), [restService]);
+  const [users, setUsers] = (0, import_react2.useState)([]);
+  const [totalCount, setTotalCount] = (0, import_react2.useState)(0);
+  const [selectedUser, setSelectedUser] = (0, import_react2.useState)(null);
+  const [selectedUserRoles, setSelectedUserRoles] = (0, import_react2.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [pageQuery, setPageQuery] = (0, import_react2.useState)(DEFAULT_PAGE_QUERY);
+  const [sortKey, setSortKey] = (0, import_react2.useState)("userName");
+  const [sortOrder, setSortOrder] = (0, import_react2.useState)("");
+  const fetchUsers = (0, import_react2.useCallback)(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      const queryParams = params || pageQuery;
+      try {
+        const response = await service.getUsers(queryParams);
+        setUsers(response.items || []);
+        setTotalCount(response.totalCount || 0);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch users";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, pageQuery]
+  );
+  const getUserById = (0, import_react2.useCallback)(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const user = await service.getUserById(id);
+        setSelectedUser(user);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch user";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const getUserRoles = (0, import_react2.useCallback)(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const response = await service.getUserRoles(id);
+        setSelectedUserRoles(response.items || []);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch user roles";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const createUser = (0, import_react2.useCallback)(
+    async (user) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.createUser(user);
+        await fetchUsers();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create user";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchUsers]
+  );
+  const updateUser = (0, import_react2.useCallback)(
+    async (id, user) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateUser(id, user);
+        await fetchUsers();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update user";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchUsers]
+  );
+  const deleteUser = (0, import_react2.useCallback)(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.deleteUser(id);
+        await fetchUsers();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete user";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchUsers]
+  );
+  const reset = (0, import_react2.useCallback)(() => {
+    setUsers([]);
+    setTotalCount(0);
+    setSelectedUser(null);
+    setSelectedUserRoles([]);
+    setIsLoading(false);
+    setError(null);
+    setPageQuery(DEFAULT_PAGE_QUERY);
+  }, []);
+  return {
+    users,
+    totalCount,
+    selectedUser,
+    selectedUserRoles,
+    isLoading,
+    error,
+    pageQuery,
+    sortKey,
+    sortOrder,
+    fetchUsers,
+    getUserById,
+    getUserRoles,
+    createUser,
+    updateUser,
+    deleteUser,
+    setSelectedUser,
+    setPageQuery,
+    setSortKey,
+    setSortOrder,
+    reset
+  };
+}
+
+// src/hooks/useIdentity.ts
+var import_react3 = require("react");
+function useIdentity() {
+  const rolesHook = useRoles();
+  const usersHook = useUsers();
+  const isLoading = (0, import_react3.useMemo)(
+    () => rolesHook.isLoading || usersHook.isLoading,
+    [rolesHook.isLoading, usersHook.isLoading]
+  );
+  const error = (0, import_react3.useMemo)(
+    () => rolesHook.error || usersHook.error,
+    [rolesHook.error, usersHook.error]
+  );
+  const resetAll = (0, import_react3.useCallback)(() => {
+    rolesHook.reset();
+    usersHook.reset();
+  }, [rolesHook, usersHook]);
+  return {
+    roles: rolesHook,
+    users: usersHook,
+    isLoading,
+    error,
+    resetAll
+  };
+}
+
+// src/hooks/useClaims.ts
+var import_react4 = require("react");
+var import_core3 = require("@abpjs/core");
+function useClaims() {
+  const restService = (0, import_core3.useRestService)();
+  const service = (0, import_react4.useMemo)(() => new IdentityService(restService), [restService]);
+  const [claimTypes, setClaimTypes] = (0, import_react4.useState)([]);
+  const [totalCount, setTotalCount] = (0, import_react4.useState)(0);
+  const [claimTypeNames, setClaimTypeNames] = (0, import_react4.useState)([]);
+  const [selectedClaimType, setSelectedClaimType] = (0, import_react4.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const [sortKey, setSortKey] = (0, import_react4.useState)("name");
+  const [sortOrder, setSortOrder] = (0, import_react4.useState)("");
+  const fetchClaimTypes = (0, import_react4.useCallback)(async (params) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await service.getClaimTypes(params);
+      setClaimTypes(response.items || []);
+      setTotalCount(response.totalCount || 0);
+      setIsLoading(false);
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch claim types";
+      setError(errorMessage);
+      setIsLoading(false);
+      return { success: false, error: errorMessage };
+    }
+  }, [service]);
+  const fetchClaimTypeNames = (0, import_react4.useCallback)(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await service.getClaimTypeNames();
+      setClaimTypeNames(response || []);
+      setIsLoading(false);
+      return { success: true };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Failed to fetch claim type names";
+      setError(errorMessage);
+      setIsLoading(false);
+      return { success: false, error: errorMessage };
+    }
+  }, [service]);
+  const getClaimTypeById = (0, import_react4.useCallback)(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const claimType = await service.getClaimTypeById(id);
+        setSelectedClaimType(claimType);
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch claim type";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const createClaimType = (0, import_react4.useCallback)(
+    async (claimType) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.createClaimType(claimType);
+        await fetchClaimTypes();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to create claim type";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchClaimTypes]
+  );
+  const updateClaimType = (0, import_react4.useCallback)(
+    async (claimType) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateClaimType(claimType);
+        await fetchClaimTypes();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update claim type";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchClaimTypes]
+  );
+  const deleteClaimType = (0, import_react4.useCallback)(
+    async (id) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.deleteClaimType(id);
+        await fetchClaimTypes();
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to delete claim type";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service, fetchClaimTypes]
+  );
+  const getClaims = (0, import_react4.useCallback)(
+    async (id, type) => {
+      try {
+        return await service.getClaims({ id, type });
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to fetch claims";
+        setError(errorMessage);
+        return [];
+      }
+    },
+    [service]
+  );
+  const updateClaims = (0, import_react4.useCallback)(
+    async (id, type, claims) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await service.updateClaims({ id, type, claims });
+        setIsLoading(false);
+        return { success: true };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to update claims";
+        setError(errorMessage);
+        setIsLoading(false);
+        return { success: false, error: errorMessage };
+      }
+    },
+    [service]
+  );
+  const reset = (0, import_react4.useCallback)(() => {
+    setClaimTypes([]);
+    setTotalCount(0);
+    setClaimTypeNames([]);
+    setSelectedClaimType(null);
+    setIsLoading(false);
+    setError(null);
+  }, []);
+  return {
+    claimTypes,
+    totalCount,
+    claimTypeNames,
+    selectedClaimType,
+    isLoading,
+    error,
+    sortKey,
+    sortOrder,
+    fetchClaimTypes,
+    fetchClaimTypeNames,
+    getClaimTypeById,
+    createClaimType,
+    updateClaimType,
+    deleteClaimType,
+    setSelectedClaimType,
+    setSortKey,
+    setSortOrder,
+    reset,
+    getClaims,
+    updateClaims
+  };
+}
+
+// src/components/Roles/RolesComponent.tsx
+var import_react5 = require("react");
+var import_core4 = require("@abpjs/core");
+var import_theme_shared = require("@abpjs/theme-shared");
+var import_permission_management = require("@abpjs/permission-management");
+var import_react6 = require("@chakra-ui/react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DEFAULT_FORM_STATE = {
+  name: "",
+  isDefault: false,
+  isPublic: false
+};
+function RolesComponent({
+  onRoleCreated,
+  onRoleUpdated,
+  onRoleDeleted
+}) {
+  const { t } = (0, import_core4.useLocalization)();
+  const confirmation = (0, import_theme_shared.useConfirmation)();
+  const {
+    roles,
+    selectedRole,
+    isLoading,
+    error,
+    fetchRoles,
+    getRoleById,
+    createRole,
+    updateRole,
+    deleteRole,
+    setSelectedRole
+  } = useRoles();
+  const [isModalOpen, setIsModalOpen] = (0, import_react5.useState)(false);
+  const [formState, setFormState] = (0, import_react5.useState)(DEFAULT_FORM_STATE);
+  const [isSubmitting, setIsSubmitting] = (0, import_react5.useState)(false);
+  const [isPermissionModalOpen, setIsPermissionModalOpen] = (0, import_react5.useState)(false);
+  const [permissionProviderKey, setPermissionProviderKey] = (0, import_react5.useState)("");
+  const [searchTerm, setSearchTerm] = (0, import_react5.useState)("");
+  (0, import_react5.useEffect)(() => {
+    fetchRoles();
+  }, [fetchRoles]);
+  const filteredRoles = roles.filter(
+    (role) => !searchTerm || role.name.toLowerCase().includes(searchTerm.toLowerCase())
+  );
+  const handleAdd = (0, import_react5.useCallback)(() => {
+    setSelectedRole(null);
+    setFormState(DEFAULT_FORM_STATE);
+    setIsModalOpen(true);
+  }, [setSelectedRole]);
+  const handleEdit = (0, import_react5.useCallback)(
+    async (id) => {
+      const result = await getRoleById(id);
+      if (result.success && selectedRole) {
+        setFormState({
+          name: selectedRole.name || "",
+          isDefault: selectedRole.isDefault || false,
+          isPublic: selectedRole.isPublic || false
+        });
+        setIsModalOpen(true);
+      }
+    },
+    [getRoleById, selectedRole]
+  );
+  (0, import_react5.useEffect)(() => {
+    if (selectedRole) {
+      setFormState({
+        name: selectedRole.name || "",
+        isDefault: selectedRole.isDefault || false,
+        isPublic: selectedRole.isPublic || false
+      });
+    }
+  }, [selectedRole]);
+  const handleDelete = (0, import_react5.useCallback)(
+    async (id, name) => {
+      const status = await confirmation.warn(
+        t("AbpIdentity::RoleDeletionConfirmationMessage", name),
+        t("AbpIdentity::AreYouSure")
+      );
+      if (status === import_theme_shared.Toaster.Status.confirm) {
+        const result = await deleteRole(id);
+        if (result.success) {
+          onRoleDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteRole, onRoleDeleted]
+  );
+  const handleOpenPermissions = (0, import_react5.useCallback)((roleName) => {
+    setPermissionProviderKey(roleName);
+    setIsPermissionModalOpen(true);
+  }, []);
+  const handleSubmit = (0, import_react5.useCallback)(async () => {
+    if (!formState.name.trim()) return;
+    setIsSubmitting(true);
+    const roleData = {
+      name: formState.name.trim(),
+      isDefault: formState.isDefault,
+      isPublic: formState.isPublic
+    };
+    let result;
+    if (selectedRole?.id) {
+      result = await updateRole(selectedRole.id, roleData);
+      if (result.success) {
+        onRoleUpdated?.({ ...selectedRole, ...roleData });
+      }
+    } else {
+      result = await createRole(roleData);
+      if (result.success) {
+        onRoleCreated?.({ ...roleData, id: "", isStatic: false, concurrencyStamp: "" });
+      }
+    }
+    setIsSubmitting(false);
+    if (result.success) {
+      setIsModalOpen(false);
+      setFormState(DEFAULT_FORM_STATE);
+      setSelectedRole(null);
+    }
+  }, [formState, selectedRole, updateRole, createRole, onRoleCreated, onRoleUpdated, setSelectedRole]);
+  const handleModalClose = (0, import_react5.useCallback)(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE);
+    setSelectedRole(null);
+  }, [setSelectedRole]);
+  const handleInputChange = (0, import_react5.useCallback)(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react6.Box, { id: "identity-roles-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react6.Flex, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Text, { fontSize: "xl", fontWeight: "bold", children: t("AbpIdentity::Roles") }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.Button, { colorPalette: "blue", onClick: handleAdd, children: t("AbpIdentity::NewRole") })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Box, { mb: 4, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_react6.Input,
+      {
+        placeholder: t("AbpIdentity::Search"),
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.Alert, { status: "error", mb: 4, children: error }),
+    isLoading && roles.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Flex, { justify: "center", py: 8, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Spinner, { size: "lg" }) }),
+    roles.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react6.Table.Root, { variant: "outline", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Table.Header, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react6.Table.Row, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Table.ColumnHeader, { children: t("AbpIdentity::Actions") }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Table.ColumnHeader, { children: t("AbpIdentity::RoleName") })
+      ] }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Table.Body, { children: filteredRoles.map((role) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react6.Table.Row, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react6.Menu.Root, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Menu.Trigger, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.Button, { size: "sm", colorPalette: "blue", children: t("AbpIdentity::Actions") }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Menu.Positioner, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react6.Menu.Content, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Menu.Item, { value: "edit", onClick: () => handleEdit(role.id), children: t("AbpIdentity::Edit") }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Menu.Item, { value: "permissions", onClick: () => handleOpenPermissions(role.name), children: t("AbpIdentity::Permissions") }),
+            !role.isStatic && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              import_react6.Menu.Item,
+              {
+                value: "delete",
+                color: "red.500",
+                onClick: () => handleDelete(role.id, role.name),
+                children: t("AbpIdentity::Delete")
+              }
+            )
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Table.Cell, { children: role.name })
+      ] }, role.id)) })
+    ] }),
+    !isLoading && roles.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react6.Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpIdentity::NoRolesFound") }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_theme_shared.Modal,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: selectedRole?.id ? t("AbpIdentity::Edit") : t("AbpIdentity::NewRole"),
+        footer: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.Button, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpIdentity::Cancel") }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_theme_shared.Button,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.name.trim(),
+              children: t("AbpIdentity::Save")
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react6.VStack, { gap: 4, align: "stretch", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_theme_shared.FormField, { label: t("AbpIdentity::RoleName"), required: true, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_react6.Input,
+            {
+              value: formState.name,
+              onChange: (e) => handleInputChange("name", e.target.value),
+              maxLength: 256,
+              placeholder: t("AbpIdentity::RoleName")
+            }
+          ) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_theme_shared.Checkbox,
+            {
+              checked: formState.isDefault,
+              onChange: (e) => handleInputChange("isDefault", e.target.checked),
+              children: t("AbpIdentity::DisplayName:IsDefault")
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_theme_shared.Checkbox,
+            {
+              checked: formState.isPublic,
+              onChange: (e) => handleInputChange("isPublic", e.target.checked),
+              children: t("AbpIdentity::DisplayName:IsPublic")
+            }
+          )
+        ] })
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_permission_management.PermissionManagementModal,
+      {
+        visible: isPermissionModalOpen,
+        onVisibleChange: setIsPermissionModalOpen,
+        providerName: "R",
+        providerKey: permissionProviderKey
+      }
+    )
+  ] });
+}
+
+// src/components/Users/UsersComponent.tsx
+var import_react7 = require("react");
+var import_core5 = require("@abpjs/core");
+var import_theme_shared2 = require("@abpjs/theme-shared");
+var import_permission_management2 = require("@abpjs/permission-management");
+var import_react8 = require("@chakra-ui/react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var DEFAULT_FORM_STATE2 = {
+  userName: "",
+  name: "",
+  surname: "",
+  email: "",
+  phoneNumber: "",
+  password: "",
+  lockoutEnabled: true,
+  twoFactorEnabled: true,
+  roleNames: []
+};
+function UsersComponent({
+  onUserCreated,
+  onUserUpdated,
+  onUserDeleted
+}) {
+  const { t } = (0, import_core5.useLocalization)();
+  const confirmation = (0, import_theme_shared2.useConfirmation)();
+  const {
+    users,
+    totalCount,
+    selectedUser,
+    selectedUserRoles,
+    isLoading,
+    error,
+    pageQuery,
+    fetchUsers,
+    getUserById,
+    getUserRoles,
+    createUser,
+    updateUser,
+    deleteUser,
+    setSelectedUser,
+    setPageQuery
+  } = useUsers();
+  const { roles, fetchRoles } = useRoles();
+  const [isModalOpen, setIsModalOpen] = (0, import_react7.useState)(false);
+  const [formState, setFormState] = (0, import_react7.useState)(DEFAULT_FORM_STATE2);
+  const [isSubmitting, setIsSubmitting] = (0, import_react7.useState)(false);
+  const [isPermissionModalOpen, setIsPermissionModalOpen] = (0, import_react7.useState)(false);
+  const [permissionProviderKey, setPermissionProviderKey] = (0, import_react7.useState)("");
+  const [searchTerm, setSearchTerm] = (0, import_react7.useState)("");
+  const [debouncedSearchTerm, setDebouncedSearchTerm] = (0, import_react7.useState)("");
+  (0, import_react7.useEffect)(() => {
+    fetchRoles();
+    fetchUsers();
+  }, [fetchRoles, fetchUsers]);
+  (0, import_react7.useEffect)(() => {
+    const timer = setTimeout(() => {
+      setDebouncedSearchTerm(searchTerm);
+    }, 300);
+    return () => clearTimeout(timer);
+  }, [searchTerm]);
+  (0, import_react7.useEffect)(() => {
+    const newQuery = {
+      ...pageQuery,
+      filter: debouncedSearchTerm || void 0,
+      skipCount: 0
+    };
+    setPageQuery(newQuery);
+    fetchUsers(newQuery);
+  }, [debouncedSearchTerm]);
+  const selectedRoleNames = (0, import_react7.useMemo)(() => {
+    return selectedUserRoles.map((role) => role.name);
+  }, [selectedUserRoles]);
+  const handleAdd = (0, import_react7.useCallback)(() => {
+    setSelectedUser(null);
+    setFormState(DEFAULT_FORM_STATE2);
+    setIsModalOpen(true);
+  }, [setSelectedUser]);
+  const handleEdit = (0, import_react7.useCallback)(
+    async (id) => {
+      await Promise.all([getUserById(id), getUserRoles(id)]);
+      setIsModalOpen(true);
+    },
+    [getUserById, getUserRoles]
+  );
+  (0, import_react7.useEffect)(() => {
+    if (selectedUser) {
+      setFormState({
+        userName: selectedUser.userName || "",
+        name: selectedUser.name || "",
+        surname: selectedUser.surname || "",
+        email: selectedUser.email || "",
+        phoneNumber: selectedUser.phoneNumber || "",
+        password: "",
+        lockoutEnabled: selectedUser.lockoutEnabled ?? true,
+        twoFactorEnabled: selectedUser.twoFactorEnabled ?? true,
+        roleNames: selectedRoleNames
+      });
+    }
+  }, [selectedUser, selectedRoleNames]);
+  const handleDelete = (0, import_react7.useCallback)(
+    async (id, userName) => {
+      const status = await confirmation.warn(
+        t("AbpIdentity::UserDeletionConfirmationMessage", userName),
+        t("AbpIdentity::AreYouSure")
+      );
+      if (status === import_theme_shared2.Toaster.Status.confirm) {
+        const result = await deleteUser(id);
+        if (result.success) {
+          onUserDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteUser, onUserDeleted]
+  );
+  const handleOpenPermissions = (0, import_react7.useCallback)((userId) => {
+    setPermissionProviderKey(userId);
+    setIsPermissionModalOpen(true);
+  }, []);
+  const handleSubmit = (0, import_react7.useCallback)(async () => {
+    if (!formState.userName.trim() || !formState.email.trim()) return;
+    if (!selectedUser?.id && !formState.password) return;
+    setIsSubmitting(true);
+    const userData = {
+      userName: formState.userName.trim(),
+      name: formState.name.trim(),
+      surname: formState.surname.trim(),
+      email: formState.email.trim(),
+      phoneNumber: formState.phoneNumber.trim(),
+      password: formState.password,
+      lockoutEnabled: formState.lockoutEnabled,
+      twoFactorEnabled: formState.twoFactorEnabled,
+      roleNames: formState.roleNames
+    };
+    let result;
+    if (selectedUser?.id) {
+      result = await updateUser(selectedUser.id, userData);
+      if (result.success) {
+        onUserUpdated?.({
+          ...selectedUser,
+          ...userData
+        });
+      }
+    } else {
+      result = await createUser(userData);
+      if (result.success) {
+        onUserCreated?.({
+          ...userData,
+          id: "",
+          tenantId: "",
+          emailConfirmed: false,
+          phoneNumberConfirmed: false,
+          isLockedOut: false,
+          concurrencyStamp: ""
+        });
+      }
+    }
+    setIsSubmitting(false);
+    if (result.success) {
+      setIsModalOpen(false);
+      setFormState(DEFAULT_FORM_STATE2);
+      setSelectedUser(null);
+    }
+  }, [formState, selectedUser, updateUser, createUser, onUserCreated, onUserUpdated, setSelectedUser]);
+  const handleModalClose = (0, import_react7.useCallback)(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE2);
+    setSelectedUser(null);
+  }, [setSelectedUser]);
+  const handleInputChange = (0, import_react7.useCallback)(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  const handleRoleChange = (0, import_react7.useCallback)((roleName, checked) => {
+    setFormState((prev) => ({
+      ...prev,
+      roleNames: checked ? [...prev.roleNames, roleName] : prev.roleNames.filter((name) => name !== roleName)
+    }));
+  }, []);
+  const handlePageChange = (0, import_react7.useCallback)(
+    (newSkipCount) => {
+      const newQuery = { ...pageQuery, skipCount: newSkipCount };
+      setPageQuery(newQuery);
+      fetchUsers(newQuery);
+    },
+    [pageQuery, setPageQuery, fetchUsers]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Box, { id: "identity-users-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Flex, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { fontSize: "xl", fontWeight: "bold", children: t("AbpIdentity::Users") }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Button, { colorPalette: "blue", onClick: handleAdd, children: t("AbpIdentity::NewUser") })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Box, { mb: 4, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_react8.Input,
+      {
+        placeholder: t("AbpIdentity::Search"),
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Alert, { status: "error", mb: 4, children: error }),
+    isLoading && users.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Flex, { justify: "center", py: 8, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Spinner, { size: "lg" }) }),
+    users.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Table.Root, { variant: "outline", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Header, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Table.Row, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpIdentity::Actions") }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpIdentity::UserName") }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpIdentity::EmailAddress") }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.ColumnHeader, { children: t("AbpIdentity::PhoneNumber") })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Body, { children: users.map((user) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Table.Row, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Menu.Root, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Menu.Trigger, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Button, { size: "sm", colorPalette: "blue", children: t("AbpIdentity::Actions") }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Menu.Positioner, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Menu.Content, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Menu.Item, { value: "edit", onClick: () => handleEdit(user.id), children: t("AbpIdentity::Edit") }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Menu.Item, { value: "permissions", onClick: () => handleOpenPermissions(user.id), children: t("AbpIdentity::Permissions") }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                import_react8.Menu.Item,
+                {
+                  value: "delete",
+                  color: "red.500",
+                  onClick: () => handleDelete(user.id, user.userName),
+                  children: t("AbpIdentity::Delete")
+                }
+              )
+            ] }) })
+          ] }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: user.userName }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: user.email }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Table.Cell, { children: user.phoneNumber })
+        ] }, user.id)) })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Flex, { justify: "space-between", align: "center", mt: 4, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Text, { color: "gray.600", children: [
+          t("AbpIdentity::TotalCount"),
+          ": ",
+          totalCount
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Flex, { gap: 2, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            import_theme_shared2.Button,
+            {
+              size: "sm",
+              disabled: (pageQuery.skipCount || 0) === 0,
+              onClick: () => handlePageChange(
+                Math.max(0, (pageQuery.skipCount || 0) - (pageQuery.maxResultCount || 10))
+              ),
+              children: t("AbpIdentity::Previous")
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            import_theme_shared2.Button,
+            {
+              size: "sm",
+              disabled: (pageQuery.skipCount || 0) + (pageQuery.maxResultCount || 10) >= totalCount,
+              onClick: () => handlePageChange((pageQuery.skipCount || 0) + (pageQuery.maxResultCount || 10)),
+              children: t("AbpIdentity::Next")
+            }
+          )
+        ] })
+      ] })
+    ] }),
+    !isLoading && users.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpIdentity::NoUsersFound") }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_theme_shared2.Modal,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        size: "lg",
+        header: selectedUser?.id ? t("AbpIdentity::Edit") : t("AbpIdentity::NewUser"),
+        footer: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.Button, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpIdentity::Cancel") }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            import_theme_shared2.Button,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.userName.trim() || !formState.email.trim() || !selectedUser?.id && !formState.password,
+              children: t("AbpIdentity::Save")
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Tabs.Root, { defaultValue: "info", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.Tabs.List, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Tabs.Trigger, { value: "info", children: t("AbpIdentity::UserInformations") }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Tabs.Trigger, { value: "roles", children: t("AbpIdentity::Roles") })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Tabs.Content, { value: "info", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.VStack, { gap: 4, align: "stretch", pt: 4, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpIdentity::UserName"), required: true, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              import_react8.Input,
+              {
+                value: formState.userName,
+                onChange: (e) => handleInputChange("userName", e.target.value),
+                maxLength: 256
+              }
+            ) }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.SimpleGrid, { columns: 2, gap: 4, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpIdentity::Name"), children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                import_react8.Input,
+                {
+                  value: formState.name,
+                  onChange: (e) => handleInputChange("name", e.target.value),
+                  maxLength: 64
+                }
+              ) }),
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpIdentity::DisplayName:Surname"), children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+                import_react8.Input,
+                {
+                  value: formState.surname,
+                  onChange: (e) => handleInputChange("surname", e.target.value),
+                  maxLength: 64
+                }
+              ) })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpIdentity::Password"), required: !selectedUser?.id, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              import_react8.Input,
+              {
+                type: "password",
+                value: formState.password,
+                onChange: (e) => handleInputChange("password", e.target.value),
+                autoComplete: "new-password",
+                maxLength: 32,
+                placeholder: selectedUser?.id ? t("AbpIdentity::LeaveBlankToKeepCurrent") : ""
+              }
+            ) }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpIdentity::EmailAddress"), required: true, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              import_react8.Input,
+              {
+                type: "email",
+                value: formState.email,
+                onChange: (e) => handleInputChange("email", e.target.value),
+                maxLength: 256
+              }
+            ) }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_theme_shared2.FormField, { label: t("AbpIdentity::PhoneNumber"), children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              import_react8.Input,
+              {
+                value: formState.phoneNumber,
+                onChange: (e) => handleInputChange("phoneNumber", e.target.value),
+                maxLength: 16
+              }
+            ) }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              import_theme_shared2.Checkbox,
+              {
+                checked: formState.lockoutEnabled,
+                onChange: (e) => handleInputChange("lockoutEnabled", e.target.checked),
+                children: t("AbpIdentity::DisplayName:LockoutEnabled")
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              import_theme_shared2.Checkbox,
+              {
+                checked: formState.twoFactorEnabled,
+                onChange: (e) => handleInputChange("twoFactorEnabled", e.target.checked),
+                children: t("AbpIdentity::DisplayName:TwoFactorEnabled")
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Tabs.Content, { value: "roles", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react8.VStack, { gap: 2, align: "stretch", pt: 4, children: [
+            roles.map((role) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              import_theme_shared2.Checkbox,
+              {
+                checked: formState.roleNames.includes(role.name),
+                onChange: (e) => handleRoleChange(role.name, e.target.checked),
+                children: role.name
+              },
+              role.id
+            )),
+            roles.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react8.Text, { color: "gray.500", children: t("AbpIdentity::NoRolesFound") })
+          ] }) })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_permission_management2.PermissionManagementModal,
+      {
+        visible: isPermissionModalOpen,
+        onVisibleChange: setIsPermissionModalOpen,
+        providerName: "U",
+        providerKey: permissionProviderKey
+      }
+    )
+  ] });
+}
+
+// src/components/Claims/ClaimsComponent.tsx
+var import_react9 = require("react");
+var import_core6 = require("@abpjs/core");
+var import_theme_shared3 = require("@abpjs/theme-shared");
+var import_react10 = require("@chakra-ui/react");
+var import_react11 = require("@chakra-ui/react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var DEFAULT_FORM_STATE3 = {
+  name: "",
+  required: false,
+  regex: "",
+  regexDescription: "",
+  description: "",
+  valueType: 0
+};
+var VALUE_TYPE_OPTIONS = [
+  { value: 0, label: "String" },
+  { value: 1, label: "Int" },
+  { value: 2, label: "Boolean" },
+  { value: 3, label: "DateTime" }
+];
+function getValueTypeName(valueType) {
+  const option = VALUE_TYPE_OPTIONS.find((opt) => opt.value === valueType);
+  return option?.label || "String";
+}
+function ClaimsComponent({
+  onClaimTypeCreated,
+  onClaimTypeUpdated,
+  onClaimTypeDeleted
+}) {
+  const { t } = (0, import_core6.useLocalization)();
+  const confirmation = (0, import_theme_shared3.useConfirmation)();
+  const {
+    claimTypes,
+    selectedClaimType,
+    isLoading,
+    error,
+    fetchClaimTypes,
+    getClaimTypeById,
+    createClaimType,
+    updateClaimType,
+    deleteClaimType,
+    setSelectedClaimType
+  } = useClaims();
+  const [isModalOpen, setIsModalOpen] = (0, import_react9.useState)(false);
+  const [formState, setFormState] = (0, import_react9.useState)(DEFAULT_FORM_STATE3);
+  const [isSubmitting, setIsSubmitting] = (0, import_react9.useState)(false);
+  const [searchTerm, setSearchTerm] = (0, import_react9.useState)("");
+  (0, import_react9.useEffect)(() => {
+    fetchClaimTypes();
+  }, [fetchClaimTypes]);
+  const filteredClaimTypes = claimTypes.filter(
+    (claim) => !searchTerm || claim.name.toLowerCase().includes(searchTerm.toLowerCase())
+  );
+  const handleAdd = (0, import_react9.useCallback)(() => {
+    setSelectedClaimType(null);
+    setFormState(DEFAULT_FORM_STATE3);
+    setIsModalOpen(true);
+  }, [setSelectedClaimType]);
+  const handleEdit = (0, import_react9.useCallback)(
+    async (id) => {
+      const result = await getClaimTypeById(id);
+      if (result.success && selectedClaimType) {
+        setFormState({
+          name: selectedClaimType.name || "",
+          required: selectedClaimType.required || false,
+          regex: selectedClaimType.regex || "",
+          regexDescription: selectedClaimType.regexDescription || "",
+          description: selectedClaimType.description || "",
+          valueType: selectedClaimType.valueType || 0
+        });
+        setIsModalOpen(true);
+      }
+    },
+    [getClaimTypeById, selectedClaimType]
+  );
+  (0, import_react9.useEffect)(() => {
+    if (selectedClaimType) {
+      setFormState({
+        name: selectedClaimType.name || "",
+        required: selectedClaimType.required || false,
+        regex: selectedClaimType.regex || "",
+        regexDescription: selectedClaimType.regexDescription || "",
+        description: selectedClaimType.description || "",
+        valueType: selectedClaimType.valueType || 0
+      });
+    }
+  }, [selectedClaimType]);
+  const handleDelete = (0, import_react9.useCallback)(
+    async (id, name) => {
+      const status = await confirmation.warn(
+        t("AbpIdentity::ClaimTypeDeletionConfirmationMessage", name) || `Are you sure you want to delete the claim type '${name}'?`,
+        t("AbpIdentity::AreYouSure")
+      );
+      if (status === import_theme_shared3.Toaster.Status.confirm) {
+        const result = await deleteClaimType(id);
+        if (result.success) {
+          onClaimTypeDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteClaimType, onClaimTypeDeleted]
+  );
+  const handleSubmit = (0, import_react9.useCallback)(async () => {
+    if (!formState.name.trim()) return;
+    setIsSubmitting(true);
+    const claimTypeData = {
+      id: selectedClaimType?.id,
+      name: formState.name.trim(),
+      required: formState.required,
+      isStatic: selectedClaimType?.isStatic || false,
+      regex: formState.regex,
+      regexDescription: formState.regexDescription,
+      description: formState.description,
+      valueType: formState.valueType
+    };
+    let result;
+    if (selectedClaimType?.id) {
+      result = await updateClaimType(claimTypeData);
+      if (result.success) {
+        onClaimTypeUpdated?.(claimTypeData);
+      }
+    } else {
+      result = await createClaimType(claimTypeData);
+      if (result.success) {
+        onClaimTypeCreated?.(claimTypeData);
+      }
+    }
+    setIsSubmitting(false);
+    if (result.success) {
+      setIsModalOpen(false);
+      setFormState(DEFAULT_FORM_STATE3);
+      setSelectedClaimType(null);
+    }
+  }, [formState, selectedClaimType, updateClaimType, createClaimType, onClaimTypeCreated, onClaimTypeUpdated, setSelectedClaimType]);
+  const handleModalClose = (0, import_react9.useCallback)(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE3);
+    setSelectedClaimType(null);
+  }, [setSelectedClaimType]);
+  const handleInputChange = (0, import_react9.useCallback)(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react10.Box, { id: "identity-claims-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react10.Flex, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Text, { fontSize: "xl", fontWeight: "bold", children: t("AbpIdentity::ClaimTypes") || "Claim Types" }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.Button, { colorPalette: "blue", onClick: handleAdd, children: t("AbpIdentity::NewClaimType") || "New Claim Type" })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Box, { mb: 4, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_react10.Input,
+      {
+        placeholder: t("AbpIdentity::Search"),
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.Alert, { status: "error", mb: 4, children: error }),
+    isLoading && claimTypes.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Flex, { justify: "center", py: 8, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Spinner, { size: "lg" }) }),
+    claimTypes.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react10.Table.Root, { variant: "outline", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.Header, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react10.Table.Row, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.ColumnHeader, { children: t("AbpIdentity::Actions") }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.ColumnHeader, { children: t("AbpIdentity::ClaimTypeName") || "Name" }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.ColumnHeader, { children: t("AbpIdentity::ValueType") || "Value Type" }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.ColumnHeader, { children: t("AbpIdentity::Description") || "Description" })
+      ] }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.Body, { children: filteredClaimTypes.map((claimType) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react10.Table.Row, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.Cell, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react10.Menu.Root, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Menu.Trigger, { asChild: true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.Button, { size: "sm", colorPalette: "blue", children: t("AbpIdentity::Actions") }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Menu.Positioner, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react10.Menu.Content, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Menu.Item, { value: "edit", onClick: () => handleEdit(claimType.id), children: t("AbpIdentity::Edit") }),
+            !claimType.isStatic && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+              import_react10.Menu.Item,
+              {
+                value: "delete",
+                color: "red.500",
+                onClick: () => handleDelete(claimType.id, claimType.name),
+                children: t("AbpIdentity::Delete")
+              }
+            )
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.Cell, { children: claimType.name }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.Cell, { children: getValueTypeName(claimType.valueType) }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Table.Cell, { children: claimType.description })
+      ] }, claimType.id)) })
+    ] }),
+    !isLoading && claimTypes.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react10.Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpIdentity::NoClaimTypesFound") || "No claim types found" }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_theme_shared3.Modal,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: selectedClaimType?.id ? t("AbpIdentity::Edit") : t("AbpIdentity::NewClaimType") || "New Claim Type",
+        footer: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.Button, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpIdentity::Cancel") }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+            import_theme_shared3.Button,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.name.trim(),
+              children: t("AbpIdentity::Save")
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react10.VStack, { gap: 4, align: "stretch", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.FormField, { label: t("AbpIdentity::ClaimTypeName") || "Name", required: true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+            import_react10.Input,
+            {
+              value: formState.name,
+              onChange: (e) => handleInputChange("name", e.target.value),
+              maxLength: 256,
+              placeholder: t("AbpIdentity::ClaimTypeName") || "Name",
+              disabled: selectedClaimType?.isStatic
+            }
+          ) }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.FormField, { label: t("AbpIdentity::ValueType") || "Value Type", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react11.NativeSelectRoot, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+            import_react11.NativeSelectField,
+            {
+              value: formState.valueType,
+              onChange: (e) => handleInputChange("valueType", parseInt(e.target.value, 10)),
+              children: VALUE_TYPE_OPTIONS.map((option) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("option", { value: option.value, children: option.label }, option.value))
+            }
+          ) }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.FormField, { label: t("AbpIdentity::Description") || "Description", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+            import_react10.Textarea,
+            {
+              value: formState.description,
+              onChange: (e) => handleInputChange("description", e.target.value),
+              placeholder: t("AbpIdentity::Description") || "Description",
+              rows: 2
+            }
+          ) }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.FormField, { label: t("AbpIdentity::Regex") || "Regex", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+            import_react10.Input,
+            {
+              value: formState.regex,
+              onChange: (e) => handleInputChange("regex", e.target.value),
+              placeholder: t("AbpIdentity::Regex") || "Regex pattern"
+            }
+          ) }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_theme_shared3.FormField, { label: t("AbpIdentity::RegexDescription") || "Regex Description", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+            import_react10.Input,
+            {
+              value: formState.regexDescription,
+              onChange: (e) => handleInputChange("regexDescription", e.target.value),
+              placeholder: t("AbpIdentity::RegexDescription") || "Regex description"
+            }
+          ) })
+        ] })
+      }
+    )
+  ] });
+}
+
+// src/components/Claims/ClaimModal.tsx
+var import_react12 = require("react");
+var import_core7 = require("@abpjs/core");
+var import_theme_shared4 = require("@abpjs/theme-shared");
+var import_react13 = require("@chakra-ui/react");
+var import_react14 = require("@chakra-ui/react");
+var import_lu = require("react-icons/lu");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function ClaimModal({
+  visible,
+  onVisibleChange,
+  subjectId,
+  subjectType,
+  onSaved
+}) {
+  const { t } = (0, import_core7.useLocalization)();
+  const {
+    claimTypeNames,
+    fetchClaimTypeNames,
+    getClaims,
+    updateClaims,
+    isLoading
+  } = useClaims();
+  const [subjectClaims, setSubjectClaims] = (0, import_react12.useState)([]);
+  const [newClaimType, setNewClaimType] = (0, import_react12.useState)("");
+  const [newClaimValue, setNewClaimValue] = (0, import_react12.useState)("");
+  const [isSaving, setIsSaving] = (0, import_react12.useState)(false);
+  const initModal = (0, import_react12.useCallback)(async () => {
+    if (!visible || !subjectId) return;
+    await fetchClaimTypeNames();
+    const claims = await getClaims(subjectId, subjectType);
+    setSubjectClaims(claims);
+  }, [visible, subjectId, subjectType, fetchClaimTypeNames, getClaims]);
+  (0, import_react12.useEffect)(() => {
+    if (visible) {
+      initModal();
+    } else {
+      setSubjectClaims([]);
+      setNewClaimType("");
+      setNewClaimValue("");
+    }
+  }, [visible, initModal]);
+  const handleAddClaim = (0, import_react12.useCallback)(() => {
+    if (!newClaimType.trim() || !newClaimValue.trim()) return;
+    const newClaim = {
+      claimType: newClaimType.trim(),
+      claimValue: newClaimValue.trim(),
+      ...subjectType === "users" ? { userId: subjectId } : { roleId: subjectId }
+    };
+    setSubjectClaims((prev) => [...prev, newClaim]);
+    setNewClaimType("");
+    setNewClaimValue("");
+  }, [newClaimType, newClaimValue, subjectId, subjectType]);
+  const handleRemoveClaim = (0, import_react12.useCallback)((index) => {
+    setSubjectClaims((prev) => prev.filter((_, i) => i !== index));
+  }, []);
+  const handleSave = (0, import_react12.useCallback)(async () => {
+    setIsSaving(true);
+    const result = await updateClaims(subjectId, subjectType, subjectClaims);
+    setIsSaving(false);
+    if (result.success) {
+      onSaved?.();
+      onVisibleChange(false);
+    }
+  }, [subjectId, subjectType, subjectClaims, updateClaims, onSaved, onVisibleChange]);
+  const handleClose = (0, import_react12.useCallback)(() => {
+    onVisibleChange(false);
+  }, [onVisibleChange]);
+  const modalTitle = subjectType === "users" ? t("AbpIdentity::UserClaims") || "User Claims" : t("AbpIdentity::RoleClaims") || "Role Claims";
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    import_theme_shared4.Modal,
+    {
+      visible,
+      onVisibleChange,
+      header: modalTitle,
+      size: "lg",
+      footer: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_theme_shared4.Button, { variant: "outline", onClick: handleClose, disabled: isSaving, children: t("AbpIdentity::Cancel") }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          import_theme_shared4.Button,
+          {
+            colorPalette: "blue",
+            onClick: handleSave,
+            loading: isSaving,
+            children: t("AbpIdentity::Save")
+          }
+        )
+      ] }),
+      children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react13.VStack, { gap: 4, align: "stretch", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react13.Box, { borderWidth: "1px", borderRadius: "md", p: 4, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react13.Text, { fontWeight: "semibold", mb: 3, children: t("AbpIdentity::AddNewClaim") || "Add New Claim" }),
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react13.HStack, { gap: 3, align: "flex-end", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react13.Box, { flex: 1, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_theme_shared4.FormField, { label: t("AbpIdentity::ClaimType") || "Claim Type", children: claimTypeNames.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react14.NativeSelectRoot, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+              import_react14.NativeSelectField,
+              {
+                value: newClaimType,
+                onChange: (e) => setNewClaimType(e.target.value),
+                placeholder: t("AbpIdentity::SelectClaimType") || "Select claim type",
+                children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("option", { value: "", children: t("AbpIdentity::SelectClaimType") || "Select claim type" }),
+                  claimTypeNames.map((ct) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("option", { value: ct.name, children: ct.name }, ct.name))
+                ]
+              }
+            ) }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+              import_react13.Input,
+              {
+                value: newClaimType,
+                onChange: (e) => setNewClaimType(e.target.value),
+                placeholder: t("AbpIdentity::ClaimType") || "Claim type"
+              }
+            ) }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react13.Box, { flex: 1, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_theme_shared4.FormField, { label: t("AbpIdentity::ClaimValue") || "Claim Value", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+              import_react13.Input,
+              {
+                value: newClaimValue,
+                onChange: (e) => setNewClaimValue(e.target.value),
+                placeholder: t("AbpIdentity::ClaimValue") || "Claim value"
+              }
+            ) }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+              import_react13.IconButton,
+              {
+                "aria-label": t("AbpIdentity::Add") || "Add",
+                colorPalette: "blue",
+                onClick: handleAddClaim,
+                disabled: !newClaimType.trim() || !newClaimValue.trim(),
+                children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_lu.LuPlus, {})
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react13.Box, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react13.Text, { fontWeight: "semibold", mb: 3, children: [
+            t("AbpIdentity::CurrentClaims") || "Current Claims",
+            " (",
+            subjectClaims.length,
+            ")"
+          ] }),
+          subjectClaims.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react13.Text, { color: "gray.500", textAlign: "center", py: 4, children: t("AbpIdentity::NoClaimsFound") || "No claims found" }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react13.VStack, { gap: 2, align: "stretch", children: subjectClaims.map((claim, index) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+            import_react13.Flex,
+            {
+              justify: "space-between",
+              align: "center",
+              p: 3,
+              borderWidth: "1px",
+              borderRadius: "md",
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react13.Box, { children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react13.Text, { fontWeight: "medium", children: claim.claimType }),
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react13.Text, { fontSize: "sm", color: "gray.600", children: claim.claimValue })
+                ] }),
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+                  import_react13.IconButton,
+                  {
+                    "aria-label": t("AbpIdentity::Remove") || "Remove",
+                    colorPalette: "red",
+                    variant: "ghost",
+                    size: "sm",
+                    onClick: () => handleRemoveClaim(index),
+                    children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_lu.LuTrash, {})
+                  }
+                )
+              ]
+            },
+            index
+          )) })
+        ] }),
+        isLoading && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react13.Text, { textAlign: "center", color: "gray.500", children: t("AbpUi::Loading") || "Loading..." })
+      ] })
+    }
+  );
+}
+
+// src/constants/routes.ts
+var import_core8 = require("@abpjs/core");
+var IDENTITY_ROUTES = {
+  routes: [
+    {
+      name: "AbpUiNavigation::Menu:Administration",
+      path: "",
+      order: 1,
+      wrapper: true
+    },
+    {
+      name: "AbpIdentity::Menu:IdentityManagement",
+      path: "identity",
+      order: 1,
+      parentName: "AbpUiNavigation::Menu:Administration",
+      layout: import_core8.eLayoutType.application,
+      children: [
+        {
+          path: "roles",
+          name: "AbpIdentity::Roles",
+          order: 2,
+          requiredPolicy: "AbpIdentity.Roles"
+        },
+        {
+          path: "users",
+          name: "AbpIdentity::Users",
+          order: 1,
+          requiredPolicy: "AbpIdentity.Users"
+        }
+      ]
+    }
+  ]
+};
+var IDENTITY_ROUTE_PATHS = {
+  /** Base path for identity module */
+  BASE: "/identity",
+  /** Roles management path */
+  ROLES: "/identity/roles",
+  /** Users management path */
+  USERS: "/identity/users"
+};
+var IDENTITY_POLICIES = {
+  /** Policy for roles management */
+  ROLES: "AbpIdentity.Roles",
+  /** Policy for users management */
+  USERS: "AbpIdentity.Users",
+  /** Policy for creating users */
+  USERS_CREATE: "AbpIdentity.Users.Create",
+  /** Policy for updating users */
+  USERS_UPDATE: "AbpIdentity.Users.Update",
+  /** Policy for deleting users */
+  USERS_DELETE: "AbpIdentity.Users.Delete",
+  /** Policy for creating roles */
+  ROLES_CREATE: "AbpIdentity.Roles.Create",
+  /** Policy for updating roles */
+  ROLES_UPDATE: "AbpIdentity.Roles.Update",
+  /** Policy for deleting roles */
+  ROLES_DELETE: "AbpIdentity.Roles.Delete"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ClaimModal,
+  ClaimsComponent,
+  IDENTITY_POLICIES,
+  IDENTITY_ROUTES,
+  IDENTITY_ROUTE_PATHS,
+  Identity,
+  IdentityService,
+  RolesComponent,
+  UsersComponent,
+  useClaims,
+  useIdentity,
+  useRoles,
+  useUsers
+});