@abpjs/identity 0.7.6

package/dist/index.d.ts

@@ -0,0 +1,463 @@
+import { ABP, RestService } from '@abpjs/core';
+import React from 'react';
+
+/**
+ * Identity namespace containing all types related to identity management.
+ * Translated from @abp/ng.identity Identity namespace.
+ */
+declare namespace Identity {
+    /**
+     * Identity state shape for state management
+     */
+    interface State {
+        roles: RoleResponse;
+        users: UserResponse;
+        selectedRole: RoleItem;
+        selectedUser: UserItem;
+        selectedUserRoles: RoleItem[];
+    }
+    /**
+     * 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[];
+    }
+}
+
+/**
+ * Service for managing identity-related API operations.
+ * Handles roles and users CRUD operations.
+ *
+ * Translated from @abp/ng.identity IdentityService
+ */
+declare class IdentityService {
+    private rest;
+    constructor(rest: RestService);
+    /**
+     * Get all roles
+     * @returns Promise with paginated role response
+     */
+    getRoles(): 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>;
+}
+
+/**
+ * Result from role operations
+ */
+interface RoleOperationResult {
+    success: boolean;
+    error?: string;
+}
+/**
+ * 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;
+    /** Fetch all roles */
+    fetchRoles: () => 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;
+    /** 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;
+    /** 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;
+    /** 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;
+
+/**
+ * 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;
+
+/**
+ * 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.
+ */
+declare const IDENTITY_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 { IDENTITY_POLICIES, IDENTITY_ROUTES, IDENTITY_ROUTE_PATHS, Identity, IdentityService, type RoleOperationResult, RolesComponent, type RolesComponentProps, type UseIdentityReturn, type UseRolesReturn, type UseUsersReturn, type UserOperationResult, UsersComponent, type UsersComponentProps, useIdentity, useRoles, useUsers };