@abpjs/identity-pro 0.7.2

package/dist/index.mjs

@@ -0,0 +1,1909 @@
+// 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
+import { useState, useCallback, useMemo } from "react";
+import { useRestService } from "@abpjs/core";
+function useRoles() {
+  const restService = useRestService();
+  const service = useMemo(() => new IdentityService(restService), [restService]);
+  const [roles, setRoles] = useState([]);
+  const [totalCount, setTotalCount] = useState(0);
+  const [selectedRole, setSelectedRole] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [sortKey, setSortKey] = useState("name");
+  const [sortOrder, setSortOrder] = useState("");
+  const fetchRoles = 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 = 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 = 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 = 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 = 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 = 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
+import { useState as useState2, useCallback as useCallback2, useMemo as useMemo2 } from "react";
+import { useRestService as useRestService2 } from "@abpjs/core";
+var DEFAULT_PAGE_QUERY = {
+  sorting: "userName",
+  skipCount: 0,
+  maxResultCount: 10
+};
+function useUsers() {
+  const restService = useRestService2();
+  const service = useMemo2(() => new IdentityService(restService), [restService]);
+  const [users, setUsers] = useState2([]);
+  const [totalCount, setTotalCount] = useState2(0);
+  const [selectedUser, setSelectedUser] = useState2(null);
+  const [selectedUserRoles, setSelectedUserRoles] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [pageQuery, setPageQuery] = useState2(DEFAULT_PAGE_QUERY);
+  const [sortKey, setSortKey] = useState2("userName");
+  const [sortOrder, setSortOrder] = useState2("");
+  const fetchUsers = useCallback2(
+    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 = useCallback2(
+    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 = useCallback2(
+    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 = useCallback2(
+    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 = useCallback2(
+    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 = useCallback2(
+    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 = useCallback2(() => {
+    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
+import { useCallback as useCallback3, useMemo as useMemo3 } from "react";
+function useIdentity() {
+  const rolesHook = useRoles();
+  const usersHook = useUsers();
+  const isLoading = useMemo3(
+    () => rolesHook.isLoading || usersHook.isLoading,
+    [rolesHook.isLoading, usersHook.isLoading]
+  );
+  const error = useMemo3(
+    () => rolesHook.error || usersHook.error,
+    [rolesHook.error, usersHook.error]
+  );
+  const resetAll = useCallback3(() => {
+    rolesHook.reset();
+    usersHook.reset();
+  }, [rolesHook, usersHook]);
+  return {
+    roles: rolesHook,
+    users: usersHook,
+    isLoading,
+    error,
+    resetAll
+  };
+}
+
+// src/hooks/useClaims.ts
+import { useState as useState3, useCallback as useCallback4, useMemo as useMemo4 } from "react";
+import { useRestService as useRestService3 } from "@abpjs/core";
+function useClaims() {
+  const restService = useRestService3();
+  const service = useMemo4(() => new IdentityService(restService), [restService]);
+  const [claimTypes, setClaimTypes] = useState3([]);
+  const [totalCount, setTotalCount] = useState3(0);
+  const [claimTypeNames, setClaimTypeNames] = useState3([]);
+  const [selectedClaimType, setSelectedClaimType] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const [sortKey, setSortKey] = useState3("name");
+  const [sortOrder, setSortOrder] = useState3("");
+  const fetchClaimTypes = useCallback4(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 = useCallback4(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 = useCallback4(
+    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 = useCallback4(
+    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 = useCallback4(
+    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 = useCallback4(
+    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 = useCallback4(
+    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 = useCallback4(
+    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 = useCallback4(() => {
+    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
+import { useEffect, useState as useState4, useCallback as useCallback5 } from "react";
+import { useLocalization } from "@abpjs/core";
+import { Modal, useConfirmation, Toaster, Alert, Button, Checkbox, FormField } from "@abpjs/theme-shared";
+import { PermissionManagementModal } from "@abpjs/permission-management";
+import {
+  Box,
+  Flex,
+  Input,
+  Table,
+  Spinner,
+  VStack,
+  Menu,
+  Text
+} from "@chakra-ui/react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_FORM_STATE = {
+  name: "",
+  isDefault: false,
+  isPublic: false
+};
+function RolesComponent({
+  onRoleCreated,
+  onRoleUpdated,
+  onRoleDeleted
+}) {
+  const { t } = useLocalization();
+  const confirmation = useConfirmation();
+  const {
+    roles,
+    selectedRole,
+    isLoading,
+    error,
+    fetchRoles,
+    getRoleById,
+    createRole,
+    updateRole,
+    deleteRole,
+    setSelectedRole
+  } = useRoles();
+  const [isModalOpen, setIsModalOpen] = useState4(false);
+  const [formState, setFormState] = useState4(DEFAULT_FORM_STATE);
+  const [isSubmitting, setIsSubmitting] = useState4(false);
+  const [isPermissionModalOpen, setIsPermissionModalOpen] = useState4(false);
+  const [permissionProviderKey, setPermissionProviderKey] = useState4("");
+  const [searchTerm, setSearchTerm] = useState4("");
+  useEffect(() => {
+    fetchRoles();
+  }, [fetchRoles]);
+  const filteredRoles = roles.filter(
+    (role) => !searchTerm || role.name.toLowerCase().includes(searchTerm.toLowerCase())
+  );
+  const handleAdd = useCallback5(() => {
+    setSelectedRole(null);
+    setFormState(DEFAULT_FORM_STATE);
+    setIsModalOpen(true);
+  }, [setSelectedRole]);
+  const handleEdit = useCallback5(
+    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]
+  );
+  useEffect(() => {
+    if (selectedRole) {
+      setFormState({
+        name: selectedRole.name || "",
+        isDefault: selectedRole.isDefault || false,
+        isPublic: selectedRole.isPublic || false
+      });
+    }
+  }, [selectedRole]);
+  const handleDelete = useCallback5(
+    async (id, name) => {
+      const status = await confirmation.warn(
+        t("AbpIdentity::RoleDeletionConfirmationMessage", name),
+        t("AbpIdentity::AreYouSure")
+      );
+      if (status === Toaster.Status.confirm) {
+        const result = await deleteRole(id);
+        if (result.success) {
+          onRoleDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteRole, onRoleDeleted]
+  );
+  const handleOpenPermissions = useCallback5((roleName) => {
+    setPermissionProviderKey(roleName);
+    setIsPermissionModalOpen(true);
+  }, []);
+  const handleSubmit = useCallback5(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 = useCallback5(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE);
+    setSelectedRole(null);
+  }, [setSelectedRole]);
+  const handleInputChange = useCallback5(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs(Box, { id: "identity-roles-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ jsxs(Flex, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ jsx(Text, { fontSize: "xl", fontWeight: "bold", children: t("AbpIdentity::Roles") }),
+      /* @__PURE__ */ jsx(Button, { colorPalette: "blue", onClick: handleAdd, children: t("AbpIdentity::NewRole") })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { mb: 4, children: /* @__PURE__ */ jsx(
+      Input,
+      {
+        placeholder: t("AbpIdentity::Search"),
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ jsx(Alert, { status: "error", mb: 4, children: error }),
+    isLoading && roles.length === 0 && /* @__PURE__ */ jsx(Flex, { justify: "center", py: 8, children: /* @__PURE__ */ jsx(Spinner, { size: "lg" }) }),
+    roles.length > 0 && /* @__PURE__ */ jsxs(Table.Root, { variant: "outline", children: [
+      /* @__PURE__ */ jsx(Table.Header, { children: /* @__PURE__ */ jsxs(Table.Row, { children: [
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpIdentity::Actions") }),
+        /* @__PURE__ */ jsx(Table.ColumnHeader, { children: t("AbpIdentity::RoleName") })
+      ] }) }),
+      /* @__PURE__ */ jsx(Table.Body, { children: filteredRoles.map((role) => /* @__PURE__ */ jsxs(Table.Row, { children: [
+        /* @__PURE__ */ jsx(Table.Cell, { children: /* @__PURE__ */ jsxs(Menu.Root, { children: [
+          /* @__PURE__ */ jsx(Menu.Trigger, { asChild: true, children: /* @__PURE__ */ jsx(Button, { size: "sm", colorPalette: "blue", children: t("AbpIdentity::Actions") }) }),
+          /* @__PURE__ */ jsx(Menu.Positioner, { children: /* @__PURE__ */ jsxs(Menu.Content, { children: [
+            /* @__PURE__ */ jsx(Menu.Item, { value: "edit", onClick: () => handleEdit(role.id), children: t("AbpIdentity::Edit") }),
+            /* @__PURE__ */ jsx(Menu.Item, { value: "permissions", onClick: () => handleOpenPermissions(role.name), children: t("AbpIdentity::Permissions") }),
+            !role.isStatic && /* @__PURE__ */ jsx(
+              Menu.Item,
+              {
+                value: "delete",
+                color: "red.500",
+                onClick: () => handleDelete(role.id, role.name),
+                children: t("AbpIdentity::Delete")
+              }
+            )
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ jsx(Table.Cell, { children: role.name })
+      ] }, role.id)) })
+    ] }),
+    !isLoading && roles.length === 0 && /* @__PURE__ */ jsx(Text, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpIdentity::NoRolesFound") }),
+    /* @__PURE__ */ jsx(
+      Modal,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: selectedRole?.id ? t("AbpIdentity::Edit") : t("AbpIdentity::NewRole"),
+        footer: /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Button, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpIdentity::Cancel") }),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.name.trim(),
+              children: t("AbpIdentity::Save")
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ jsxs(VStack, { gap: 4, align: "stretch", children: [
+          /* @__PURE__ */ jsx(FormField, { label: t("AbpIdentity::RoleName"), required: true, children: /* @__PURE__ */ jsx(
+            Input,
+            {
+              value: formState.name,
+              onChange: (e) => handleInputChange("name", e.target.value),
+              maxLength: 256,
+              placeholder: t("AbpIdentity::RoleName")
+            }
+          ) }),
+          /* @__PURE__ */ jsx(
+            Checkbox,
+            {
+              checked: formState.isDefault,
+              onChange: (e) => handleInputChange("isDefault", e.target.checked),
+              children: t("AbpIdentity::DisplayName:IsDefault")
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Checkbox,
+            {
+              checked: formState.isPublic,
+              onChange: (e) => handleInputChange("isPublic", e.target.checked),
+              children: t("AbpIdentity::DisplayName:IsPublic")
+            }
+          )
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      PermissionManagementModal,
+      {
+        visible: isPermissionModalOpen,
+        onVisibleChange: setIsPermissionModalOpen,
+        providerName: "R",
+        providerKey: permissionProviderKey
+      }
+    )
+  ] });
+}
+
+// src/components/Users/UsersComponent.tsx
+import { useEffect as useEffect2, useState as useState5, useCallback as useCallback6, useMemo as useMemo5 } from "react";
+import { useLocalization as useLocalization2 } from "@abpjs/core";
+import { Modal as Modal2, useConfirmation as useConfirmation2, Toaster as Toaster2, Alert as Alert2, Button as Button2, Checkbox as Checkbox2, FormField as FormField2 } from "@abpjs/theme-shared";
+import { PermissionManagementModal as PermissionManagementModal2 } from "@abpjs/permission-management";
+import {
+  Box as Box2,
+  Flex as Flex2,
+  Input as Input2,
+  Table as Table2,
+  Spinner as Spinner2,
+  VStack as VStack2,
+  Menu as Menu2,
+  Text as Text2,
+  Tabs,
+  SimpleGrid
+} from "@chakra-ui/react";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "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 } = useLocalization2();
+  const confirmation = useConfirmation2();
+  const {
+    users,
+    totalCount,
+    selectedUser,
+    selectedUserRoles,
+    isLoading,
+    error,
+    pageQuery,
+    fetchUsers,
+    getUserById,
+    getUserRoles,
+    createUser,
+    updateUser,
+    deleteUser,
+    setSelectedUser,
+    setPageQuery
+  } = useUsers();
+  const { roles, fetchRoles } = useRoles();
+  const [isModalOpen, setIsModalOpen] = useState5(false);
+  const [formState, setFormState] = useState5(DEFAULT_FORM_STATE2);
+  const [isSubmitting, setIsSubmitting] = useState5(false);
+  const [isPermissionModalOpen, setIsPermissionModalOpen] = useState5(false);
+  const [permissionProviderKey, setPermissionProviderKey] = useState5("");
+  const [searchTerm, setSearchTerm] = useState5("");
+  const [debouncedSearchTerm, setDebouncedSearchTerm] = useState5("");
+  useEffect2(() => {
+    fetchRoles();
+    fetchUsers();
+  }, [fetchRoles, fetchUsers]);
+  useEffect2(() => {
+    const timer = setTimeout(() => {
+      setDebouncedSearchTerm(searchTerm);
+    }, 300);
+    return () => clearTimeout(timer);
+  }, [searchTerm]);
+  useEffect2(() => {
+    const newQuery = {
+      ...pageQuery,
+      filter: debouncedSearchTerm || void 0,
+      skipCount: 0
+    };
+    setPageQuery(newQuery);
+    fetchUsers(newQuery);
+  }, [debouncedSearchTerm]);
+  const selectedRoleNames = useMemo5(() => {
+    return selectedUserRoles.map((role) => role.name);
+  }, [selectedUserRoles]);
+  const handleAdd = useCallback6(() => {
+    setSelectedUser(null);
+    setFormState(DEFAULT_FORM_STATE2);
+    setIsModalOpen(true);
+  }, [setSelectedUser]);
+  const handleEdit = useCallback6(
+    async (id) => {
+      await Promise.all([getUserById(id), getUserRoles(id)]);
+      setIsModalOpen(true);
+    },
+    [getUserById, getUserRoles]
+  );
+  useEffect2(() => {
+    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 = useCallback6(
+    async (id, userName) => {
+      const status = await confirmation.warn(
+        t("AbpIdentity::UserDeletionConfirmationMessage", userName),
+        t("AbpIdentity::AreYouSure")
+      );
+      if (status === Toaster2.Status.confirm) {
+        const result = await deleteUser(id);
+        if (result.success) {
+          onUserDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteUser, onUserDeleted]
+  );
+  const handleOpenPermissions = useCallback6((userId) => {
+    setPermissionProviderKey(userId);
+    setIsPermissionModalOpen(true);
+  }, []);
+  const handleSubmit = useCallback6(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 = useCallback6(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE2);
+    setSelectedUser(null);
+  }, [setSelectedUser]);
+  const handleInputChange = useCallback6(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  const handleRoleChange = useCallback6((roleName, checked) => {
+    setFormState((prev) => ({
+      ...prev,
+      roleNames: checked ? [...prev.roleNames, roleName] : prev.roleNames.filter((name) => name !== roleName)
+    }));
+  }, []);
+  const handlePageChange = useCallback6(
+    (newSkipCount) => {
+      const newQuery = { ...pageQuery, skipCount: newSkipCount };
+      setPageQuery(newQuery);
+      fetchUsers(newQuery);
+    },
+    [pageQuery, setPageQuery, fetchUsers]
+  );
+  return /* @__PURE__ */ jsxs2(Box2, { id: "identity-users-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ jsxs2(Flex2, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ jsx2(Text2, { fontSize: "xl", fontWeight: "bold", children: t("AbpIdentity::Users") }),
+      /* @__PURE__ */ jsx2(Button2, { colorPalette: "blue", onClick: handleAdd, children: t("AbpIdentity::NewUser") })
+    ] }),
+    /* @__PURE__ */ jsx2(Box2, { mb: 4, children: /* @__PURE__ */ jsx2(
+      Input2,
+      {
+        placeholder: t("AbpIdentity::Search"),
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ jsx2(Alert2, { status: "error", mb: 4, children: error }),
+    isLoading && users.length === 0 && /* @__PURE__ */ jsx2(Flex2, { justify: "center", py: 8, children: /* @__PURE__ */ jsx2(Spinner2, { size: "lg" }) }),
+    users.length > 0 && /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsxs2(Table2.Root, { variant: "outline", children: [
+        /* @__PURE__ */ jsx2(Table2.Header, { children: /* @__PURE__ */ jsxs2(Table2.Row, { children: [
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpIdentity::Actions") }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpIdentity::UserName") }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpIdentity::EmailAddress") }),
+          /* @__PURE__ */ jsx2(Table2.ColumnHeader, { children: t("AbpIdentity::PhoneNumber") })
+        ] }) }),
+        /* @__PURE__ */ jsx2(Table2.Body, { children: users.map((user) => /* @__PURE__ */ jsxs2(Table2.Row, { children: [
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: /* @__PURE__ */ jsxs2(Menu2.Root, { children: [
+            /* @__PURE__ */ jsx2(Menu2.Trigger, { asChild: true, children: /* @__PURE__ */ jsx2(Button2, { size: "sm", colorPalette: "blue", children: t("AbpIdentity::Actions") }) }),
+            /* @__PURE__ */ jsx2(Menu2.Positioner, { children: /* @__PURE__ */ jsxs2(Menu2.Content, { children: [
+              /* @__PURE__ */ jsx2(Menu2.Item, { value: "edit", onClick: () => handleEdit(user.id), children: t("AbpIdentity::Edit") }),
+              /* @__PURE__ */ jsx2(Menu2.Item, { value: "permissions", onClick: () => handleOpenPermissions(user.id), children: t("AbpIdentity::Permissions") }),
+              /* @__PURE__ */ jsx2(
+                Menu2.Item,
+                {
+                  value: "delete",
+                  color: "red.500",
+                  onClick: () => handleDelete(user.id, user.userName),
+                  children: t("AbpIdentity::Delete")
+                }
+              )
+            ] }) })
+          ] }) }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: user.userName }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: user.email }),
+          /* @__PURE__ */ jsx2(Table2.Cell, { children: user.phoneNumber })
+        ] }, user.id)) })
+      ] }),
+      /* @__PURE__ */ jsxs2(Flex2, { justify: "space-between", align: "center", mt: 4, children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: "gray.600", children: [
+          t("AbpIdentity::TotalCount"),
+          ": ",
+          totalCount
+        ] }),
+        /* @__PURE__ */ jsxs2(Flex2, { gap: 2, children: [
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              size: "sm",
+              disabled: (pageQuery.skipCount || 0) === 0,
+              onClick: () => handlePageChange(
+                Math.max(0, (pageQuery.skipCount || 0) - (pageQuery.maxResultCount || 10))
+              ),
+              children: t("AbpIdentity::Previous")
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              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__ */ jsx2(Text2, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpIdentity::NoUsersFound") }),
+    /* @__PURE__ */ jsx2(
+      Modal2,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        size: "lg",
+        header: selectedUser?.id ? t("AbpIdentity::Edit") : t("AbpIdentity::NewUser"),
+        footer: /* @__PURE__ */ jsxs2(Fragment2, { children: [
+          /* @__PURE__ */ jsx2(Button2, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpIdentity::Cancel") }),
+          /* @__PURE__ */ jsx2(
+            Button2,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.userName.trim() || !formState.email.trim() || !selectedUser?.id && !formState.password,
+              children: t("AbpIdentity::Save")
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ jsxs2(Tabs.Root, { defaultValue: "info", children: [
+          /* @__PURE__ */ jsxs2(Tabs.List, { children: [
+            /* @__PURE__ */ jsx2(Tabs.Trigger, { value: "info", children: t("AbpIdentity::UserInformations") }),
+            /* @__PURE__ */ jsx2(Tabs.Trigger, { value: "roles", children: t("AbpIdentity::Roles") })
+          ] }),
+          /* @__PURE__ */ jsx2(Tabs.Content, { value: "info", children: /* @__PURE__ */ jsxs2(VStack2, { gap: 4, align: "stretch", pt: 4, children: [
+            /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::UserName"), required: true, children: /* @__PURE__ */ jsx2(
+              Input2,
+              {
+                value: formState.userName,
+                onChange: (e) => handleInputChange("userName", e.target.value),
+                maxLength: 256
+              }
+            ) }),
+            /* @__PURE__ */ jsxs2(SimpleGrid, { columns: 2, gap: 4, children: [
+              /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::Name"), children: /* @__PURE__ */ jsx2(
+                Input2,
+                {
+                  value: formState.name,
+                  onChange: (e) => handleInputChange("name", e.target.value),
+                  maxLength: 64
+                }
+              ) }),
+              /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::DisplayName:Surname"), children: /* @__PURE__ */ jsx2(
+                Input2,
+                {
+                  value: formState.surname,
+                  onChange: (e) => handleInputChange("surname", e.target.value),
+                  maxLength: 64
+                }
+              ) })
+            ] }),
+            /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::Password"), required: !selectedUser?.id, children: /* @__PURE__ */ jsx2(
+              Input2,
+              {
+                type: "password",
+                value: formState.password,
+                onChange: (e) => handleInputChange("password", e.target.value),
+                autoComplete: "new-password",
+                maxLength: 32,
+                placeholder: selectedUser?.id ? t("AbpIdentity::LeaveBlankToKeepCurrent") : ""
+              }
+            ) }),
+            /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::EmailAddress"), required: true, children: /* @__PURE__ */ jsx2(
+              Input2,
+              {
+                type: "email",
+                value: formState.email,
+                onChange: (e) => handleInputChange("email", e.target.value),
+                maxLength: 256
+              }
+            ) }),
+            /* @__PURE__ */ jsx2(FormField2, { label: t("AbpIdentity::PhoneNumber"), children: /* @__PURE__ */ jsx2(
+              Input2,
+              {
+                value: formState.phoneNumber,
+                onChange: (e) => handleInputChange("phoneNumber", e.target.value),
+                maxLength: 16
+              }
+            ) }),
+            /* @__PURE__ */ jsx2(
+              Checkbox2,
+              {
+                checked: formState.lockoutEnabled,
+                onChange: (e) => handleInputChange("lockoutEnabled", e.target.checked),
+                children: t("AbpIdentity::DisplayName:LockoutEnabled")
+              }
+            ),
+            /* @__PURE__ */ jsx2(
+              Checkbox2,
+              {
+                checked: formState.twoFactorEnabled,
+                onChange: (e) => handleInputChange("twoFactorEnabled", e.target.checked),
+                children: t("AbpIdentity::DisplayName:TwoFactorEnabled")
+              }
+            )
+          ] }) }),
+          /* @__PURE__ */ jsx2(Tabs.Content, { value: "roles", children: /* @__PURE__ */ jsxs2(VStack2, { gap: 2, align: "stretch", pt: 4, children: [
+            roles.map((role) => /* @__PURE__ */ jsx2(
+              Checkbox2,
+              {
+                checked: formState.roleNames.includes(role.name),
+                onChange: (e) => handleRoleChange(role.name, e.target.checked),
+                children: role.name
+              },
+              role.id
+            )),
+            roles.length === 0 && /* @__PURE__ */ jsx2(Text2, { color: "gray.500", children: t("AbpIdentity::NoRolesFound") })
+          ] }) })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      PermissionManagementModal2,
+      {
+        visible: isPermissionModalOpen,
+        onVisibleChange: setIsPermissionModalOpen,
+        providerName: "U",
+        providerKey: permissionProviderKey
+      }
+    )
+  ] });
+}
+
+// src/components/Claims/ClaimsComponent.tsx
+import { useEffect as useEffect3, useState as useState6, useCallback as useCallback7 } from "react";
+import { useLocalization as useLocalization3 } from "@abpjs/core";
+import { Modal as Modal3, useConfirmation as useConfirmation3, Toaster as Toaster3, Alert as Alert3, Button as Button3, FormField as FormField3 } from "@abpjs/theme-shared";
+import {
+  Box as Box3,
+  Flex as Flex3,
+  Input as Input3,
+  Table as Table3,
+  Spinner as Spinner3,
+  VStack as VStack3,
+  Menu as Menu3,
+  Text as Text3,
+  Textarea
+} from "@chakra-ui/react";
+import { NativeSelectRoot, NativeSelectField } from "@chakra-ui/react";
+import { Fragment as Fragment3, jsx as jsx3, jsxs as jsxs3 } from "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 } = useLocalization3();
+  const confirmation = useConfirmation3();
+  const {
+    claimTypes,
+    selectedClaimType,
+    isLoading,
+    error,
+    fetchClaimTypes,
+    getClaimTypeById,
+    createClaimType,
+    updateClaimType,
+    deleteClaimType,
+    setSelectedClaimType
+  } = useClaims();
+  const [isModalOpen, setIsModalOpen] = useState6(false);
+  const [formState, setFormState] = useState6(DEFAULT_FORM_STATE3);
+  const [isSubmitting, setIsSubmitting] = useState6(false);
+  const [searchTerm, setSearchTerm] = useState6("");
+  useEffect3(() => {
+    fetchClaimTypes();
+  }, [fetchClaimTypes]);
+  const filteredClaimTypes = claimTypes.filter(
+    (claim) => !searchTerm || claim.name.toLowerCase().includes(searchTerm.toLowerCase())
+  );
+  const handleAdd = useCallback7(() => {
+    setSelectedClaimType(null);
+    setFormState(DEFAULT_FORM_STATE3);
+    setIsModalOpen(true);
+  }, [setSelectedClaimType]);
+  const handleEdit = useCallback7(
+    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]
+  );
+  useEffect3(() => {
+    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 = useCallback7(
+    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 === Toaster3.Status.confirm) {
+        const result = await deleteClaimType(id);
+        if (result.success) {
+          onClaimTypeDeleted?.(id);
+        }
+      }
+    },
+    [confirmation, t, deleteClaimType, onClaimTypeDeleted]
+  );
+  const handleSubmit = useCallback7(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 = useCallback7(() => {
+    setIsModalOpen(false);
+    setFormState(DEFAULT_FORM_STATE3);
+    setSelectedClaimType(null);
+  }, [setSelectedClaimType]);
+  const handleInputChange = useCallback7(
+    (field, value) => {
+      setFormState((prev) => ({ ...prev, [field]: value }));
+    },
+    []
+  );
+  return /* @__PURE__ */ jsxs3(Box3, { id: "identity-claims-wrapper", className: "card", p: 4, children: [
+    /* @__PURE__ */ jsxs3(Flex3, { justify: "space-between", align: "center", mb: 4, children: [
+      /* @__PURE__ */ jsx3(Text3, { fontSize: "xl", fontWeight: "bold", children: t("AbpIdentity::ClaimTypes") || "Claim Types" }),
+      /* @__PURE__ */ jsx3(Button3, { colorPalette: "blue", onClick: handleAdd, children: t("AbpIdentity::NewClaimType") || "New Claim Type" })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { mb: 4, children: /* @__PURE__ */ jsx3(
+      Input3,
+      {
+        placeholder: t("AbpIdentity::Search"),
+        value: searchTerm,
+        onChange: (e) => setSearchTerm(e.target.value),
+        maxW: "300px"
+      }
+    ) }),
+    error && /* @__PURE__ */ jsx3(Alert3, { status: "error", mb: 4, children: error }),
+    isLoading && claimTypes.length === 0 && /* @__PURE__ */ jsx3(Flex3, { justify: "center", py: 8, children: /* @__PURE__ */ jsx3(Spinner3, { size: "lg" }) }),
+    claimTypes.length > 0 && /* @__PURE__ */ jsxs3(Table3.Root, { variant: "outline", children: [
+      /* @__PURE__ */ jsx3(Table3.Header, { children: /* @__PURE__ */ jsxs3(Table3.Row, { children: [
+        /* @__PURE__ */ jsx3(Table3.ColumnHeader, { children: t("AbpIdentity::Actions") }),
+        /* @__PURE__ */ jsx3(Table3.ColumnHeader, { children: t("AbpIdentity::ClaimTypeName") || "Name" }),
+        /* @__PURE__ */ jsx3(Table3.ColumnHeader, { children: t("AbpIdentity::ValueType") || "Value Type" }),
+        /* @__PURE__ */ jsx3(Table3.ColumnHeader, { children: t("AbpIdentity::Description") || "Description" })
+      ] }) }),
+      /* @__PURE__ */ jsx3(Table3.Body, { children: filteredClaimTypes.map((claimType) => /* @__PURE__ */ jsxs3(Table3.Row, { children: [
+        /* @__PURE__ */ jsx3(Table3.Cell, { children: /* @__PURE__ */ jsxs3(Menu3.Root, { children: [
+          /* @__PURE__ */ jsx3(Menu3.Trigger, { asChild: true, children: /* @__PURE__ */ jsx3(Button3, { size: "sm", colorPalette: "blue", children: t("AbpIdentity::Actions") }) }),
+          /* @__PURE__ */ jsx3(Menu3.Positioner, { children: /* @__PURE__ */ jsxs3(Menu3.Content, { children: [
+            /* @__PURE__ */ jsx3(Menu3.Item, { value: "edit", onClick: () => handleEdit(claimType.id), children: t("AbpIdentity::Edit") }),
+            !claimType.isStatic && /* @__PURE__ */ jsx3(
+              Menu3.Item,
+              {
+                value: "delete",
+                color: "red.500",
+                onClick: () => handleDelete(claimType.id, claimType.name),
+                children: t("AbpIdentity::Delete")
+              }
+            )
+          ] }) })
+        ] }) }),
+        /* @__PURE__ */ jsx3(Table3.Cell, { children: claimType.name }),
+        /* @__PURE__ */ jsx3(Table3.Cell, { children: getValueTypeName(claimType.valueType) }),
+        /* @__PURE__ */ jsx3(Table3.Cell, { children: claimType.description })
+      ] }, claimType.id)) })
+    ] }),
+    !isLoading && claimTypes.length === 0 && /* @__PURE__ */ jsx3(Text3, { textAlign: "center", color: "gray.500", py: 8, children: t("AbpIdentity::NoClaimTypesFound") || "No claim types found" }),
+    /* @__PURE__ */ jsx3(
+      Modal3,
+      {
+        visible: isModalOpen,
+        onVisibleChange: setIsModalOpen,
+        header: selectedClaimType?.id ? t("AbpIdentity::Edit") : t("AbpIdentity::NewClaimType") || "New Claim Type",
+        footer: /* @__PURE__ */ jsxs3(Fragment3, { children: [
+          /* @__PURE__ */ jsx3(Button3, { variant: "outline", onClick: handleModalClose, disabled: isSubmitting, children: t("AbpIdentity::Cancel") }),
+          /* @__PURE__ */ jsx3(
+            Button3,
+            {
+              colorPalette: "blue",
+              onClick: handleSubmit,
+              loading: isSubmitting,
+              disabled: !formState.name.trim(),
+              children: t("AbpIdentity::Save")
+            }
+          )
+        ] }),
+        children: /* @__PURE__ */ jsxs3(VStack3, { gap: 4, align: "stretch", children: [
+          /* @__PURE__ */ jsx3(FormField3, { label: t("AbpIdentity::ClaimTypeName") || "Name", required: true, children: /* @__PURE__ */ jsx3(
+            Input3,
+            {
+              value: formState.name,
+              onChange: (e) => handleInputChange("name", e.target.value),
+              maxLength: 256,
+              placeholder: t("AbpIdentity::ClaimTypeName") || "Name",
+              disabled: selectedClaimType?.isStatic
+            }
+          ) }),
+          /* @__PURE__ */ jsx3(FormField3, { label: t("AbpIdentity::ValueType") || "Value Type", children: /* @__PURE__ */ jsx3(NativeSelectRoot, { children: /* @__PURE__ */ jsx3(
+            NativeSelectField,
+            {
+              value: formState.valueType,
+              onChange: (e) => handleInputChange("valueType", parseInt(e.target.value, 10)),
+              children: VALUE_TYPE_OPTIONS.map((option) => /* @__PURE__ */ jsx3("option", { value: option.value, children: option.label }, option.value))
+            }
+          ) }) }),
+          /* @__PURE__ */ jsx3(FormField3, { label: t("AbpIdentity::Description") || "Description", children: /* @__PURE__ */ jsx3(
+            Textarea,
+            {
+              value: formState.description,
+              onChange: (e) => handleInputChange("description", e.target.value),
+              placeholder: t("AbpIdentity::Description") || "Description",
+              rows: 2
+            }
+          ) }),
+          /* @__PURE__ */ jsx3(FormField3, { label: t("AbpIdentity::Regex") || "Regex", children: /* @__PURE__ */ jsx3(
+            Input3,
+            {
+              value: formState.regex,
+              onChange: (e) => handleInputChange("regex", e.target.value),
+              placeholder: t("AbpIdentity::Regex") || "Regex pattern"
+            }
+          ) }),
+          /* @__PURE__ */ jsx3(FormField3, { label: t("AbpIdentity::RegexDescription") || "Regex Description", children: /* @__PURE__ */ jsx3(
+            Input3,
+            {
+              value: formState.regexDescription,
+              onChange: (e) => handleInputChange("regexDescription", e.target.value),
+              placeholder: t("AbpIdentity::RegexDescription") || "Regex description"
+            }
+          ) })
+        ] })
+      }
+    )
+  ] });
+}
+
+// src/components/Claims/ClaimModal.tsx
+import { useEffect as useEffect4, useState as useState7, useCallback as useCallback8 } from "react";
+import { useLocalization as useLocalization4 } from "@abpjs/core";
+import { Modal as Modal4, Button as Button4, FormField as FormField4 } from "@abpjs/theme-shared";
+import {
+  Box as Box4,
+  Flex as Flex4,
+  Input as Input4,
+  VStack as VStack4,
+  HStack,
+  IconButton,
+  Text as Text4
+} from "@chakra-ui/react";
+import { NativeSelectRoot as NativeSelectRoot2, NativeSelectField as NativeSelectField2 } from "@chakra-ui/react";
+import { LuTrash, LuPlus } from "react-icons/lu";
+import { Fragment as Fragment4, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function ClaimModal({
+  visible,
+  onVisibleChange,
+  subjectId,
+  subjectType,
+  onSaved
+}) {
+  const { t } = useLocalization4();
+  const {
+    claimTypeNames,
+    fetchClaimTypeNames,
+    getClaims,
+    updateClaims,
+    isLoading
+  } = useClaims();
+  const [subjectClaims, setSubjectClaims] = useState7([]);
+  const [newClaimType, setNewClaimType] = useState7("");
+  const [newClaimValue, setNewClaimValue] = useState7("");
+  const [isSaving, setIsSaving] = useState7(false);
+  const initModal = useCallback8(async () => {
+    if (!visible || !subjectId) return;
+    await fetchClaimTypeNames();
+    const claims = await getClaims(subjectId, subjectType);
+    setSubjectClaims(claims);
+  }, [visible, subjectId, subjectType, fetchClaimTypeNames, getClaims]);
+  useEffect4(() => {
+    if (visible) {
+      initModal();
+    } else {
+      setSubjectClaims([]);
+      setNewClaimType("");
+      setNewClaimValue("");
+    }
+  }, [visible, initModal]);
+  const handleAddClaim = useCallback8(() => {
+    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 = useCallback8((index) => {
+    setSubjectClaims((prev) => prev.filter((_, i) => i !== index));
+  }, []);
+  const handleSave = useCallback8(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 = useCallback8(() => {
+    onVisibleChange(false);
+  }, [onVisibleChange]);
+  const modalTitle = subjectType === "users" ? t("AbpIdentity::UserClaims") || "User Claims" : t("AbpIdentity::RoleClaims") || "Role Claims";
+  return /* @__PURE__ */ jsx4(
+    Modal4,
+    {
+      visible,
+      onVisibleChange,
+      header: modalTitle,
+      size: "lg",
+      footer: /* @__PURE__ */ jsxs4(Fragment4, { children: [
+        /* @__PURE__ */ jsx4(Button4, { variant: "outline", onClick: handleClose, disabled: isSaving, children: t("AbpIdentity::Cancel") }),
+        /* @__PURE__ */ jsx4(
+          Button4,
+          {
+            colorPalette: "blue",
+            onClick: handleSave,
+            loading: isSaving,
+            children: t("AbpIdentity::Save")
+          }
+        )
+      ] }),
+      children: /* @__PURE__ */ jsxs4(VStack4, { gap: 4, align: "stretch", children: [
+        /* @__PURE__ */ jsxs4(Box4, { borderWidth: "1px", borderRadius: "md", p: 4, children: [
+          /* @__PURE__ */ jsx4(Text4, { fontWeight: "semibold", mb: 3, children: t("AbpIdentity::AddNewClaim") || "Add New Claim" }),
+          /* @__PURE__ */ jsxs4(HStack, { gap: 3, align: "flex-end", children: [
+            /* @__PURE__ */ jsx4(Box4, { flex: 1, children: /* @__PURE__ */ jsx4(FormField4, { label: t("AbpIdentity::ClaimType") || "Claim Type", children: claimTypeNames.length > 0 ? /* @__PURE__ */ jsx4(NativeSelectRoot2, { children: /* @__PURE__ */ jsxs4(
+              NativeSelectField2,
+              {
+                value: newClaimType,
+                onChange: (e) => setNewClaimType(e.target.value),
+                placeholder: t("AbpIdentity::SelectClaimType") || "Select claim type",
+                children: [
+                  /* @__PURE__ */ jsx4("option", { value: "", children: t("AbpIdentity::SelectClaimType") || "Select claim type" }),
+                  claimTypeNames.map((ct) => /* @__PURE__ */ jsx4("option", { value: ct.name, children: ct.name }, ct.name))
+                ]
+              }
+            ) }) : /* @__PURE__ */ jsx4(
+              Input4,
+              {
+                value: newClaimType,
+                onChange: (e) => setNewClaimType(e.target.value),
+                placeholder: t("AbpIdentity::ClaimType") || "Claim type"
+              }
+            ) }) }),
+            /* @__PURE__ */ jsx4(Box4, { flex: 1, children: /* @__PURE__ */ jsx4(FormField4, { label: t("AbpIdentity::ClaimValue") || "Claim Value", children: /* @__PURE__ */ jsx4(
+              Input4,
+              {
+                value: newClaimValue,
+                onChange: (e) => setNewClaimValue(e.target.value),
+                placeholder: t("AbpIdentity::ClaimValue") || "Claim value"
+              }
+            ) }) }),
+            /* @__PURE__ */ jsx4(
+              IconButton,
+              {
+                "aria-label": t("AbpIdentity::Add") || "Add",
+                colorPalette: "blue",
+                onClick: handleAddClaim,
+                disabled: !newClaimType.trim() || !newClaimValue.trim(),
+                children: /* @__PURE__ */ jsx4(LuPlus, {})
+              }
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsxs4(Text4, { fontWeight: "semibold", mb: 3, children: [
+            t("AbpIdentity::CurrentClaims") || "Current Claims",
+            " (",
+            subjectClaims.length,
+            ")"
+          ] }),
+          subjectClaims.length === 0 ? /* @__PURE__ */ jsx4(Text4, { color: "gray.500", textAlign: "center", py: 4, children: t("AbpIdentity::NoClaimsFound") || "No claims found" }) : /* @__PURE__ */ jsx4(VStack4, { gap: 2, align: "stretch", children: subjectClaims.map((claim, index) => /* @__PURE__ */ jsxs4(
+            Flex4,
+            {
+              justify: "space-between",
+              align: "center",
+              p: 3,
+              borderWidth: "1px",
+              borderRadius: "md",
+              children: [
+                /* @__PURE__ */ jsxs4(Box4, { children: [
+                  /* @__PURE__ */ jsx4(Text4, { fontWeight: "medium", children: claim.claimType }),
+                  /* @__PURE__ */ jsx4(Text4, { fontSize: "sm", color: "gray.600", children: claim.claimValue })
+                ] }),
+                /* @__PURE__ */ jsx4(
+                  IconButton,
+                  {
+                    "aria-label": t("AbpIdentity::Remove") || "Remove",
+                    colorPalette: "red",
+                    variant: "ghost",
+                    size: "sm",
+                    onClick: () => handleRemoveClaim(index),
+                    children: /* @__PURE__ */ jsx4(LuTrash, {})
+                  }
+                )
+              ]
+            },
+            index
+          )) })
+        ] }),
+        isLoading && /* @__PURE__ */ jsx4(Text4, { textAlign: "center", color: "gray.500", children: t("AbpUi::Loading") || "Loading..." })
+      ] })
+    }
+  );
+}
+
+// src/constants/routes.ts
+import { eLayoutType } from "@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: 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"
+};
+export {
+  ClaimModal,
+  ClaimsComponent,
+  IDENTITY_POLICIES,
+  IDENTITY_ROUTES,
+  IDENTITY_ROUTE_PATHS,
+  Identity,
+  IdentityService,
+  RolesComponent,
+  UsersComponent,
+  useClaims,
+  useIdentity,
+  useRoles,
+  useUsers
+};