@abpjs/identity-pro 0.7.2

package/dist/index.d.mts

@@ -0,0 +1,805 @@
+import { ABP, RestService } from '@abpjs/core';
+import React from 'react';
+
+/**
+ * Identity namespace containing all types related to identity management.
+ * Translated from @volo/abp.ng.identity Identity namespace.
+ *
+ * Pro features include:
+ * - Claim type management
+ * - User/Role claims management
+ *
+ * @since 0.7.2
+ */
+declare namespace Identity {
+    /**
+     * Identity state shape for state management
+     */
+    interface State {
+        roles: RoleResponse;
+        users: UserResponse;
+        selectedRole: RoleItem;
+        selectedUser: UserItem;
+        selectedUserRoles: RoleItem[];
+        /** Pro: Claim type names for dropdowns */
+        claimTypes: ClaimTypeName[];
+        /** Pro: Paginated claim types response */
+        claims: ClaimResponse;
+        /** Pro: Selected claim type for editing */
+        selectedClaim: ClaimType;
+    }
+    /**
+     * Paginated response for roles
+     */
+    type RoleResponse = ABP.PagedResponse<RoleItem>;
+    /**
+     * Request payload for creating/updating a role
+     */
+    interface RoleSaveRequest {
+        name: string;
+        isDefault: boolean;
+        isPublic: boolean;
+    }
+    /**
+     * Role item returned from the API
+     */
+    interface RoleItem extends RoleSaveRequest {
+        isStatic: boolean;
+        concurrencyStamp: string;
+        id: string;
+    }
+    /**
+     * Paginated response for users
+     */
+    type UserResponse = ABP.PagedResponse<UserItem>;
+    /**
+     * Base user properties
+     */
+    interface User {
+        userName: string;
+        name: string;
+        surname: string;
+        email: string;
+        phoneNumber: string;
+        twoFactorEnabled: boolean;
+        lockoutEnabled: boolean;
+    }
+    /**
+     * User item returned from the API
+     */
+    interface UserItem extends User {
+        tenantId: string;
+        emailConfirmed: boolean;
+        phoneNumberConfirmed: boolean;
+        isLockedOut: boolean;
+        concurrencyStamp: string;
+        id: string;
+    }
+    /**
+     * Request payload for creating/updating a user
+     */
+    interface UserSaveRequest extends User {
+        password: string;
+        roleNames: string[];
+    }
+    /**
+     * Simple claim type name for dropdowns
+     * Pro feature since 0.7.2
+     */
+    interface ClaimTypeName {
+        name: string;
+    }
+    /**
+     * Full claim type definition
+     * Pro feature since 0.7.2
+     */
+    interface ClaimType {
+        /** Optional ID for existing claim types */
+        id?: string;
+        /** Claim type name (e.g., 'email', 'role') */
+        name: string;
+        /** Whether this claim is required */
+        required: boolean;
+        /** Whether this claim type is static (built-in) */
+        isStatic: boolean;
+        /** Regex pattern for value validation */
+        regex: string;
+        /** Human-readable description of the regex pattern */
+        regexDescription: string;
+        /** Claim type description */
+        description: string;
+        /** Value type: 0=String, 1=Int, 2=Boolean, 3=DateTime */
+        valueType: number;
+        /** String representation of value type */
+        valueTypeAsString?: string;
+    }
+    /**
+     * Claim request for assigning claims to users or roles
+     * Pro feature since 0.7.2
+     */
+    interface ClaimRequest {
+        /** User ID (for user claims) */
+        userId?: string;
+        /** Role ID (for role claims) */
+        roleId?: string;
+        /** The claim type name */
+        claimType: string;
+        /** The claim value */
+        claimValue: string;
+    }
+    /**
+     * Paginated response for claim types
+     * Pro feature since 0.7.2
+     */
+    type ClaimResponse = ABP.PagedResponse<ClaimType>;
+    /**
+     * Value type enumeration for claim types
+     * Pro feature since 0.7.2
+     */
+    enum ClaimValueType {
+        String = 0,
+        Int = 1,
+        Boolean = 2,
+        DateTime = 3
+    }
+}
+
+/**
+ * Service for managing identity-related API operations.
+ * Handles roles, users, and claim types CRUD operations.
+ *
+ * Pro features include:
+ * - Claim type management
+ * - User/Role claims management
+ *
+ * Translated from @volo/abp.ng.identity IdentityService
+ * @since 0.7.2
+ */
+declare class IdentityService {
+    private rest;
+    constructor(rest: RestService);
+    /**
+     * 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?: ABP.PageQueryParams): Promise<Identity.RoleResponse>;
+    /**
+     * Get a role by ID
+     * @param id - The role ID
+     * @returns Promise with the role item
+     */
+    getRoleById(id: string): Promise<Identity.RoleItem>;
+    /**
+     * Delete a role
+     * @param id - The role ID to delete
+     * @returns Promise with the deleted role
+     */
+    deleteRole(id: string): Promise<Identity.RoleItem>;
+    /**
+     * Create a new role
+     * @param body - The role data to create
+     * @returns Promise with the created role
+     */
+    createRole(body: Identity.RoleSaveRequest): Promise<Identity.RoleItem>;
+    /**
+     * 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: string, body: Identity.RoleSaveRequest): Promise<Identity.RoleItem>;
+    /**
+     * Get users with pagination and filtering
+     * @param params - Query parameters for pagination and filtering
+     * @returns Promise with paginated user response
+     */
+    getUsers(params?: ABP.PageQueryParams): Promise<Identity.UserResponse>;
+    /**
+     * Get a user by ID
+     * @param id - The user ID
+     * @returns Promise with the user item
+     */
+    getUserById(id: string): Promise<Identity.UserItem>;
+    /**
+     * Get roles assigned to a user
+     * @param id - The user ID
+     * @returns Promise with the user's roles
+     */
+    getUserRoles(id: string): Promise<Identity.RoleResponse>;
+    /**
+     * Delete a user
+     * @param id - The user ID to delete
+     * @returns Promise resolving when complete
+     */
+    deleteUser(id: string): Promise<void>;
+    /**
+     * Create a new user
+     * @param body - The user data to create
+     * @returns Promise with the created user
+     */
+    createUser(body: Identity.UserSaveRequest): Promise<Identity.UserItem>;
+    /**
+     * 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: string, body: Identity.UserSaveRequest): Promise<Identity.UserItem>;
+    /**
+     * Get all claim type names for dropdowns
+     * Pro feature since 0.7.2
+     * @returns Promise with claim type names
+     */
+    getClaimTypeNames(): Promise<Identity.ClaimTypeName[]>;
+    /**
+     * 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?: ABP.PageQueryParams): Promise<Identity.ClaimResponse>;
+    /**
+     * 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: string): Promise<Identity.ClaimType>;
+    /**
+     * 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: Identity.ClaimType): Promise<Identity.ClaimType>;
+    /**
+     * 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: Identity.ClaimType): Promise<Identity.ClaimType>;
+    /**
+     * 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: string): Promise<void>;
+    /**
+     * 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: {
+        id: string;
+        type: 'roles' | 'users';
+    }): Promise<Identity.ClaimRequest[]>;
+    /**
+     * 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: {
+        id: string;
+        type: 'roles' | 'users';
+        claims: Identity.ClaimRequest[];
+    }): Promise<void>;
+}
+
+/**
+ * Result from role operations
+ */
+interface RoleOperationResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Sort order type
+ * @since 1.0.0
+ */
+type SortOrder = 'asc' | 'desc' | '';
+/**
+ * Return type for useRoles hook
+ */
+interface UseRolesReturn {
+    /** List of roles */
+    roles: Identity.RoleItem[];
+    /** Total count of roles */
+    totalCount: number;
+    /** Currently selected role for editing */
+    selectedRole: Identity.RoleItem | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Current sort key @since 1.0.0 */
+    sortKey: string;
+    /** Current sort order @since 1.0.0 */
+    sortOrder: SortOrder;
+    /** Fetch all roles with optional pagination/filtering */
+    fetchRoles: (params?: ABP.PageQueryParams) => Promise<RoleOperationResult>;
+    /** Get a role by ID and set it as selected */
+    getRoleById: (id: string) => Promise<RoleOperationResult>;
+    /** Create a new role */
+    createRole: (role: Identity.RoleSaveRequest) => Promise<RoleOperationResult>;
+    /** Update an existing role */
+    updateRole: (id: string, role: Identity.RoleSaveRequest) => Promise<RoleOperationResult>;
+    /** Delete a role */
+    deleteRole: (id: string) => Promise<RoleOperationResult>;
+    /** Set the selected role */
+    setSelectedRole: (role: Identity.RoleItem | null) => void;
+    /** Set sort key @since 1.0.0 */
+    setSortKey: (key: string) => void;
+    /** Set sort order @since 1.0.0 */
+    setSortOrder: (order: SortOrder) => void;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook for managing roles
+ *
+ * This hook provides all the state and actions needed for role management.
+ * It handles fetching, creating, updating, and deleting roles.
+ *
+ * @example
+ * ```tsx
+ * function RolesPage() {
+ *   const {
+ *     roles,
+ *     isLoading,
+ *     fetchRoles,
+ *     createRole,
+ *     deleteRole,
+ *   } = useRoles();
+ *
+ *   useEffect(() => {
+ *     fetchRoles();
+ *   }, [fetchRoles]);
+ *
+ *   const handleCreate = async (data: Identity.RoleSaveRequest) => {
+ *     const result = await createRole(data);
+ *     if (result.success) {
+ *       // Handle success
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {roles.map(role => (
+ *         <div key={role.id}>{role.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useRoles(): UseRolesReturn;
+
+/**
+ * Result from user operations
+ */
+interface UserOperationResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Return type for useUsers hook
+ */
+interface UseUsersReturn {
+    /** List of users */
+    users: Identity.UserItem[];
+    /** Total count of users */
+    totalCount: number;
+    /** Currently selected user for editing */
+    selectedUser: Identity.UserItem | null;
+    /** Roles assigned to the selected user */
+    selectedUserRoles: Identity.RoleItem[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Current page query parameters */
+    pageQuery: ABP.PageQueryParams;
+    /** Current sort key @since 1.0.0 */
+    sortKey: string;
+    /** Current sort order @since 1.0.0 */
+    sortOrder: SortOrder;
+    /** Fetch users with pagination */
+    fetchUsers: (params?: ABP.PageQueryParams) => Promise<UserOperationResult>;
+    /** Get a user by ID and set it as selected */
+    getUserById: (id: string) => Promise<UserOperationResult>;
+    /** Get roles for a user */
+    getUserRoles: (id: string) => Promise<UserOperationResult>;
+    /** Create a new user */
+    createUser: (user: Identity.UserSaveRequest) => Promise<UserOperationResult>;
+    /** Update an existing user */
+    updateUser: (id: string, user: Identity.UserSaveRequest) => Promise<UserOperationResult>;
+    /** Delete a user */
+    deleteUser: (id: string) => Promise<UserOperationResult>;
+    /** Set the selected user */
+    setSelectedUser: (user: Identity.UserItem | null) => void;
+    /** Set page query parameters */
+    setPageQuery: (query: ABP.PageQueryParams) => void;
+    /** Set sort key @since 1.0.0 */
+    setSortKey: (key: string) => void;
+    /** Set sort order @since 1.0.0 */
+    setSortOrder: (order: SortOrder) => void;
+    /** Reset state */
+    reset: () => void;
+}
+/**
+ * Hook for managing users
+ *
+ * This hook provides all the state and actions needed for user management.
+ * It handles fetching, creating, updating, and deleting users with pagination support.
+ *
+ * @example
+ * ```tsx
+ * function UsersPage() {
+ *   const {
+ *     users,
+ *     totalCount,
+ *     isLoading,
+ *     pageQuery,
+ *     fetchUsers,
+ *     createUser,
+ *     deleteUser,
+ *     setPageQuery,
+ *   } = useUsers();
+ *
+ *   useEffect(() => {
+ *     fetchUsers();
+ *   }, [fetchUsers]);
+ *
+ *   const handlePageChange = (page: number) => {
+ *     setPageQuery({ ...pageQuery, skipCount: page * 10 });
+ *     fetchUsers({ ...pageQuery, skipCount: page * 10 });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {users.map(user => (
+ *         <div key={user.id}>{user.userName}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useUsers(): UseUsersReturn;
+
+/**
+ * Combined identity management return type
+ */
+interface UseIdentityReturn {
+    /** Role management hook */
+    roles: UseRolesReturn;
+    /** User management hook */
+    users: UseUsersReturn;
+    /** Combined loading state */
+    isLoading: boolean;
+    /** Combined error state */
+    error: string | null;
+    /** Reset all state */
+    resetAll: () => void;
+}
+/**
+ * Hook that combines role and user management for identity operations
+ *
+ * This hook provides a unified interface for managing both roles and users.
+ * It combines the useRoles and useUsers hooks for convenience.
+ *
+ * @example
+ * ```tsx
+ * function IdentityManagement() {
+ *   const { roles, users, isLoading } = useIdentity();
+ *
+ *   useEffect(() => {
+ *     roles.fetchRoles();
+ *     users.fetchUsers();
+ *   }, []);
+ *
+ *   return (
+ *     <div>
+ *       <h2>Roles</h2>
+ *       {roles.roles.map(role => <div key={role.id}>{role.name}</div>)}
+ *
+ *       <h2>Users</h2>
+ *       {users.users.map(user => <div key={user.id}>{user.userName}</div>)}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useIdentity(): UseIdentityReturn;
+
+/**
+ * Result from claim operations
+ * @since 0.7.2
+ */
+interface ClaimOperationResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * Return type for useClaims hook
+ * @since 0.7.2
+ */
+interface UseClaimsReturn {
+    /** List of claim types */
+    claimTypes: Identity.ClaimType[];
+    /** Total count of claim types */
+    totalCount: number;
+    /** Claim type names for dropdowns */
+    claimTypeNames: Identity.ClaimTypeName[];
+    /** Currently selected claim type for editing */
+    selectedClaimType: Identity.ClaimType | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Current sort key */
+    sortKey: string;
+    /** Current sort order */
+    sortOrder: SortOrder;
+    /** Fetch all claim types with optional pagination/filtering */
+    fetchClaimTypes: (params?: ABP.PageQueryParams) => Promise<ClaimOperationResult>;
+    /** Fetch claim type names for dropdowns */
+    fetchClaimTypeNames: () => Promise<ClaimOperationResult>;
+    /** Get a claim type by ID and set it as selected */
+    getClaimTypeById: (id: string) => Promise<ClaimOperationResult>;
+    /** Create a new claim type */
+    createClaimType: (claimType: Identity.ClaimType) => Promise<ClaimOperationResult>;
+    /** Update an existing claim type */
+    updateClaimType: (claimType: Identity.ClaimType) => Promise<ClaimOperationResult>;
+    /** Delete a claim type */
+    deleteClaimType: (id: string) => Promise<ClaimOperationResult>;
+    /** Set the selected claim type */
+    setSelectedClaimType: (claimType: Identity.ClaimType | null) => void;
+    /** Set sort key */
+    setSortKey: (key: string) => void;
+    /** Set sort order */
+    setSortOrder: (order: SortOrder) => void;
+    /** Reset state */
+    reset: () => void;
+    /** Get claims for a user or role */
+    getClaims: (id: string, type: 'users' | 'roles') => Promise<Identity.ClaimRequest[]>;
+    /** Update claims for a user or role */
+    updateClaims: (id: string, type: 'users' | 'roles', claims: Identity.ClaimRequest[]) => Promise<ClaimOperationResult>;
+}
+/**
+ * Hook for managing claim types
+ *
+ * This hook provides all the state and actions needed for claim type management.
+ * It handles fetching, creating, updating, and deleting claim types.
+ *
+ * Pro feature since 0.7.2
+ *
+ * @example
+ * ```tsx
+ * function ClaimsPage() {
+ *   const {
+ *     claimTypes,
+ *     isLoading,
+ *     fetchClaimTypes,
+ *     createClaimType,
+ *     deleteClaimType,
+ *   } = useClaims();
+ *
+ *   useEffect(() => {
+ *     fetchClaimTypes();
+ *   }, [fetchClaimTypes]);
+ *
+ *   const handleCreate = async (data: Identity.ClaimType) => {
+ *     const result = await createClaimType(data);
+ *     if (result.success) {
+ *       // Handle success
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {claimTypes.map(claim => (
+ *         <div key={claim.id}>{claim.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useClaims(): UseClaimsReturn;
+
+/**
+ * Props for RolesComponent
+ */
+interface RolesComponentProps {
+    /** Optional callback when a role is created */
+    onRoleCreated?: (role: Identity.RoleItem) => void;
+    /** Optional callback when a role is updated */
+    onRoleUpdated?: (role: Identity.RoleItem) => void;
+    /** Optional callback when a role is deleted */
+    onRoleDeleted?: (id: string) => void;
+}
+/**
+ * RolesComponent - Component for managing roles
+ *
+ * This is the React equivalent of Angular's RolesComponent.
+ * It displays a table of roles with CRUD operations and permission management.
+ *
+ * @example
+ * ```tsx
+ * function IdentityPage() {
+ *   return (
+ *     <RolesComponent
+ *       onRoleCreated={(role) => console.log('Role created:', role)}
+ *       onRoleDeleted={(id) => console.log('Role deleted:', id)}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function RolesComponent({ onRoleCreated, onRoleUpdated, onRoleDeleted, }: RolesComponentProps): React.ReactElement;
+
+/**
+ * Props for UsersComponent
+ */
+interface UsersComponentProps {
+    /** Optional callback when a user is created */
+    onUserCreated?: (user: Identity.UserItem) => void;
+    /** Optional callback when a user is updated */
+    onUserUpdated?: (user: Identity.UserItem) => void;
+    /** Optional callback when a user is deleted */
+    onUserDeleted?: (id: string) => void;
+}
+/**
+ * UsersComponent - Component for managing users
+ *
+ * This is the React equivalent of Angular's UsersComponent.
+ * It displays a table of users with CRUD operations, role assignment, and permission management.
+ *
+ * @example
+ * ```tsx
+ * function IdentityPage() {
+ *   return (
+ *     <UsersComponent
+ *       onUserCreated={(user) => console.log('User created:', user)}
+ *       onUserDeleted={(id) => console.log('User deleted:', id)}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function UsersComponent({ onUserCreated, onUserUpdated, onUserDeleted, }: UsersComponentProps): React.ReactElement;
+
+/**
+ * Props for ClaimsComponent
+ * @since 0.7.2
+ */
+interface ClaimsComponentProps {
+    /** Optional callback when a claim type is created */
+    onClaimTypeCreated?: (claimType: Identity.ClaimType) => void;
+    /** Optional callback when a claim type is updated */
+    onClaimTypeUpdated?: (claimType: Identity.ClaimType) => void;
+    /** Optional callback when a claim type is deleted */
+    onClaimTypeDeleted?: (id: string) => void;
+}
+/**
+ * ClaimsComponent - Component for managing claim types
+ *
+ * This is the React equivalent of Angular's ClaimsComponent.
+ * It displays a table of claim types with CRUD operations.
+ *
+ * Pro feature since 0.7.2
+ *
+ * @example
+ * ```tsx
+ * function IdentityProPage() {
+ *   return (
+ *     <ClaimsComponent
+ *       onClaimTypeCreated={(claim) => console.log('Claim type created:', claim)}
+ *       onClaimTypeDeleted={(id) => console.log('Claim type deleted:', id)}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function ClaimsComponent({ onClaimTypeCreated, onClaimTypeUpdated, onClaimTypeDeleted, }: ClaimsComponentProps): React.ReactElement;
+
+/**
+ * Props for ClaimModal component
+ * @since 0.7.2
+ */
+interface ClaimModalProps {
+    /** Whether the modal is visible */
+    visible: boolean;
+    /** Callback when visibility changes */
+    onVisibleChange: (visible: boolean) => void;
+    /** Subject ID (user or role ID) */
+    subjectId: string;
+    /** Subject type ('users' or 'roles') */
+    subjectType: 'users' | 'roles';
+    /** Callback when claims are saved */
+    onSaved?: () => void;
+}
+/**
+ * ClaimModal - Modal for managing claims on users or roles
+ *
+ * This is the React equivalent of Angular's ClaimModalComponent.
+ * It allows adding, editing, and removing claims for a user or role.
+ *
+ * Pro feature since 0.7.2
+ *
+ * @example
+ * ```tsx
+ * function UserClaimsButton({ userId }: { userId: string }) {
+ *   const [showClaimModal, setShowClaimModal] = useState(false);
+ *
+ *   return (
+ *     <>
+ *       <Button onClick={() => setShowClaimModal(true)}>Manage Claims</Button>
+ *       <ClaimModal
+ *         visible={showClaimModal}
+ *         onVisibleChange={setShowClaimModal}
+ *         subjectId={userId}
+ *         subjectType="users"
+ *       />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function ClaimModal({ visible, onVisibleChange, subjectId, subjectType, onSaved, }: ClaimModalProps): React.ReactElement;
+
+/**
+ * Identity module routes configuration.
+ * Translated from @abp/ng.identity IDENTITY_ROUTES.
+ *
+ * These routes define the navigation structure for the identity module
+ * within the ABP Framework application.
+ *
+ * @deprecated since version 1.0.0. Route configuration is now handled by
+ * identity config services. This constant is kept for backwards compatibility
+ * but may be removed in future versions.
+ */
+declare const IDENTITY_ROUTES: {
+    routes: ABP.FullRoute[];
+};
+/**
+ * Route paths for the identity module.
+ * Use these constants for programmatic navigation.
+ */
+declare const IDENTITY_ROUTE_PATHS: {
+    /** Base path for identity module */
+    readonly BASE: "/identity";
+    /** Roles management path */
+    readonly ROLES: "/identity/roles";
+    /** Users management path */
+    readonly USERS: "/identity/users";
+};
+/**
+ * Required policies for identity module routes.
+ */
+declare const IDENTITY_POLICIES: {
+    /** Policy for roles management */
+    readonly ROLES: "AbpIdentity.Roles";
+    /** Policy for users management */
+    readonly USERS: "AbpIdentity.Users";
+    /** Policy for creating users */
+    readonly USERS_CREATE: "AbpIdentity.Users.Create";
+    /** Policy for updating users */
+    readonly USERS_UPDATE: "AbpIdentity.Users.Update";
+    /** Policy for deleting users */
+    readonly USERS_DELETE: "AbpIdentity.Users.Delete";
+    /** Policy for creating roles */
+    readonly ROLES_CREATE: "AbpIdentity.Roles.Create";
+    /** Policy for updating roles */
+    readonly ROLES_UPDATE: "AbpIdentity.Roles.Update";
+    /** Policy for deleting roles */
+    readonly ROLES_DELETE: "AbpIdentity.Roles.Delete";
+};
+
+export { ClaimModal, type ClaimModalProps, type ClaimOperationResult, ClaimsComponent, type ClaimsComponentProps, IDENTITY_POLICIES, IDENTITY_ROUTES, IDENTITY_ROUTE_PATHS, Identity, IdentityService, type RoleOperationResult, RolesComponent, type RolesComponentProps, type SortOrder, type UseClaimsReturn, type UseIdentityReturn, type UseRolesReturn, type UseUsersReturn, type UserOperationResult, UsersComponent, type UsersComponentProps, useClaims, useIdentity, useRoles, useUsers };