@abpjs/identity 3.1.0 → 4.0.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { RoutesService, ABP, RestService } from '@abpjs/core';
+import { RoutesService, ExtensibleEntityDto, ExtensibleFullAuditedEntityDto, ExtensibleObject, PagedAndSortedResultRequestDto, PagedResultDto, RestService, ListResultDto } from '@abpjs/core';
 import React from 'react';
 
 /**
@@ -67,17 +67,17 @@ type IdentityRouteNameKey = (typeof eIdentityRouteNames)[keyof typeof eIdentityR
  * Configures the identity module routes.
  * Returns a function that adds the routes to the RoutesService.
  *
- * @param routes - The RoutesService instance to add routes to
+ * @param routesService - The RoutesService instance to add routes to
  * @returns A function that adds the identity routes when called
  *
  * @example
  * ```typescript
  * const routes = getRoutesService();
- * const addRoutes = configureRoutes(routes);
+ * const addRoutes = configureRoutes(routesService);
  * addRoutes();
  * ```
  */
-declare function configureRoutes(routes: RoutesService): () => void;
+declare function configureRoutes(routesService: RoutesService): () => void;
 /**
  * Identity route providers configuration object.
  * Use this to configure identity routes in your application.
@@ -86,7 +86,7 @@ declare function configureRoutes(routes: RoutesService): () => void;
  * ```typescript
  * // In your app initialization:
  * const routes = getRoutesService();
- * const addRoutes = IDENTITY_ROUTE_PROVIDERS.configureRoutes(routes);
+ * const addRoutes = IDENTITY_ROUTE_PROVIDERS.configureRoutes(routesService);
  * addRoutes();
  * ```
  */
@@ -127,84 +127,185 @@ declare const eIdentityComponents: {
  */
 type IdentityComponentKey = (typeof eIdentityComponents)[keyof typeof eIdentityComponents];
 
+/**
+ * Identity Proxy Models
+ * Translated from @abp/ng.identity v3.2.0
+ *
+ * These are the new typed DTOs for identity API operations.
+ * @since 3.2.0
+ */
+/**
+ * Input for changing password
+ * @since 3.2.0
+ */
+interface ChangePasswordInput {
+    currentPassword: string;
+    newPassword: string;
+}
+/**
+ * Profile DTO returned from API
+ * @since 3.2.0
+ */
+interface ProfileDto extends ExtensibleObject {
+    userName: string;
+    email: string;
+    name: string;
+    surname: string;
+    phoneNumber: string;
+    isExternal: boolean;
+    hasPassword: boolean;
+}
+/**
+ * Input for updating profile
+ * @since 3.2.0
+ */
+interface UpdateProfileDto extends ExtensibleObject {
+    userName: string;
+    email: string;
+    name: string;
+    surname: string;
+    phoneNumber: string;
+}
+/**
+ * Base DTO for role create/update operations
+ * @since 3.2.0
+ */
+interface IdentityRoleCreateOrUpdateDtoBase extends ExtensibleObject {
+    name: string;
+    isDefault: boolean;
+    isPublic: boolean;
+}
+/**
+ * DTO for creating a role
+ * @since 3.2.0
+ */
+type IdentityRoleCreateDto = IdentityRoleCreateOrUpdateDtoBase;
+/**
+ * DTO for updating a role
+ * @since 3.2.0
+ */
+interface IdentityRoleUpdateDto extends IdentityRoleCreateOrUpdateDtoBase {
+    concurrencyStamp: string;
+}
+/**
+ * Role DTO returned from API
+ * @since 3.2.0
+ */
+interface IdentityRoleDto extends ExtensibleEntityDto<string> {
+    name: string;
+    isDefault: boolean;
+    isStatic: boolean;
+    isPublic: boolean;
+    concurrencyStamp: string;
+}
+/**
+ * Input for getting users with pagination and filtering
+ * @since 3.2.0
+ */
+interface GetIdentityUsersInput extends PagedAndSortedResultRequestDto {
+    filter: string;
+}
+/**
+ * Base DTO for user create/update operations
+ * @since 3.2.0
+ */
+interface IdentityUserCreateOrUpdateDtoBase extends ExtensibleObject {
+    userName: string;
+    name: string;
+    surname: string;
+    email: string;
+    phoneNumber: string;
+    lockoutEnabled: boolean;
+    roleNames: string[];
+}
+/**
+ * DTO for creating a user
+ * @since 3.2.0
+ */
+interface IdentityUserCreateDto extends IdentityUserCreateOrUpdateDtoBase {
+    password: string;
+}
+/**
+ * DTO for updating a user
+ * @since 3.2.0
+ */
+interface IdentityUserUpdateDto extends IdentityUserCreateOrUpdateDtoBase {
+    password: string;
+    concurrencyStamp: string;
+}
+/**
+ * DTO for updating user roles
+ * @since 3.2.0
+ */
+interface IdentityUserUpdateRolesDto {
+    roleNames: string[];
+}
+/**
+ * User DTO returned from API
+ * @since 3.2.0
+ */
+interface IdentityUserDto extends ExtensibleFullAuditedEntityDto<string> {
+    tenantId?: string;
+    userName: string;
+    name: string;
+    surname: string;
+    email: string;
+    emailConfirmed: boolean;
+    phoneNumber: string;
+    phoneNumberConfirmed: boolean;
+    lockoutEnabled: boolean;
+    lockoutEnd?: string;
+    concurrencyStamp: string;
+}
+/**
+ * Input for counting users in lookup
+ * @since 3.2.0
+ */
+interface UserLookupCountInputDto {
+    filter: string;
+}
+/**
+ * Input for searching users in lookup
+ * @since 3.2.0
+ */
+interface UserLookupSearchInputDto extends PagedAndSortedResultRequestDto {
+    filter: string;
+}
+
 /**
  * Identity namespace containing all types related to identity management.
  * Translated from @abp/ng.identity Identity namespace.
+ *
+ * Changes in v4.0.0:
+ * - Removed deprecated legacy types (RoleResponse, RoleSaveRequest, RoleItem,
+ *   UserResponse, User, UserItem, UserSaveRequest)
+ * - Component interface types now use IdentityRoleDto/IdentityUserDto
+ *
+ * Changes in v3.2.0:
+ * - State now uses PagedResultDto and new proxy DTOs (IdentityRoleDto, IdentityUserDto)
  */
 declare namespace Identity {
     /**
      * Identity state shape for state management
+     * @updated 3.2.0 - Now uses PagedResultDto and new proxy DTOs
      */
     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[];
+        roles: PagedResultDto<IdentityRoleDto>;
+        users: PagedResultDto<IdentityUserDto>;
+        selectedRole: IdentityRoleDto;
+        selectedUser: IdentityUserDto;
+        selectedUserRoles: IdentityRoleDto[];
     }
     /**
      * Input props for RolesComponent
      * @since 2.0.0
+     * @updated 4.0.0 - Callbacks now use IdentityRoleDto instead of RoleItem
      */
     interface RolesComponentInputs {
         /** Callback when a role is created */
-        readonly onRoleCreated?: (role: RoleItem) => void;
+        readonly onRoleCreated?: (role: IdentityRoleDto) => void;
         /** Callback when a role is updated */
-        readonly onRoleUpdated?: (role: RoleItem) => void;
+        readonly onRoleUpdated?: (role: IdentityRoleDto) => void;
         /** Callback when a role is deleted */
         readonly onRoleDeleted?: (id: string) => void;
     }
@@ -219,12 +320,13 @@ declare namespace Identity {
     /**
      * Input props for UsersComponent
      * @since 2.0.0
+     * @updated 4.0.0 - Callbacks now use IdentityUserDto instead of UserItem
      */
     interface UsersComponentInputs {
         /** Callback when a user is created */
-        readonly onUserCreated?: (user: UserItem) => void;
+        readonly onUserCreated?: (user: IdentityUserDto) => void;
         /** Callback when a user is updated */
-        readonly onUserUpdated?: (user: UserItem) => void;
+        readonly onUserUpdated?: (user: IdentityUserDto) => void;
         /** Callback when a user is deleted */
         readonly onUserDeleted?: (id: string) => void;
         /** Password validation rules to display */
@@ -243,109 +345,228 @@ declare namespace Identity {
 }
 
 /**
- * Service for managing identity-related API operations.
- * Handles roles and users CRUD operations.
- *
- * Translated from @abp/ng.identity IdentityService v3.0.0
+ * Identity Role proxy service for role management API calls
+ * Translated from @abp/ng.identity v3.2.0
  *
- * @since 3.0.0 - Added getUserAssignableRoles method
+ * @since 3.2.0
  */
-declare class IdentityService {
-    private rest;
+declare class IdentityRoleService {
+    private restService;
     /**
      * The API name used for REST requests.
-     * @since 2.4.0
      */
     apiName: string;
-    constructor(rest: RestService);
+    constructor(restService: 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
+     * Create a new role
+     * @param input - The role data to create
+     * @returns Promise with the created role
      */
-    getRoles(params?: ABP.PageQueryParams): Promise<Identity.RoleResponse>;
+    create: (input: IdentityRoleCreateDto) => Promise<IdentityRoleDto>;
     /**
-     * Get all roles without pagination.
-     * Fetches all roles in a single request.
-     * @since 2.4.0
-     * @returns Promise with all roles
+     * Delete a role by ID
+     * @param id - The role ID to delete
+     * @returns Promise that resolves when deletion is complete
      */
-    getAllRoles(): Promise<Identity.RoleResponse>;
+    delete: (id: string) => Promise<void>;
     /**
      * Get a role by ID
      * @param id - The role ID
-     * @returns Promise with the role item
+     * @returns Promise with the role
      */
-    getRoleById(id: string): Promise<Identity.RoleItem>;
+    get: (id: string) => Promise<IdentityRoleDto>;
     /**
-     * Delete a role
-     * @param id - The role ID to delete
-     * @returns Promise with the deleted role
+     * Get all roles without pagination
+     * @returns Promise with all roles
      */
-    deleteRole(id: string): Promise<Identity.RoleItem>;
+    getAllList: () => Promise<ListResultDto<IdentityRoleDto>>;
     /**
-     * Create a new role
-     * @param body - The role data to create
-     * @returns Promise with the created role
+     * Get roles with pagination
+     * @param input - Pagination and sorting parameters
+     * @returns Promise with paginated roles
      */
-    createRole(body: Identity.RoleSaveRequest): Promise<Identity.RoleItem>;
+    getList: (input: PagedAndSortedResultRequestDto) => Promise<PagedResultDto<IdentityRoleDto>>;
     /**
-     * Update an existing role
+     * Update a role
      * @param id - The role ID to update
-     * @param body - The updated role data
+     * @param input - The updated role data
      * @returns Promise with the updated role
      */
-    updateRole(id: string, body: Identity.RoleSaveRequest): Promise<Identity.RoleItem>;
+    update: (id: string, input: IdentityRoleUpdateDto) => Promise<IdentityRoleDto>;
+}
+
+/**
+ * User data models for user lookup
+ * Translated from @abp/ng.identity v3.2.0
+ * @since 3.2.0
+ */
+/**
+ * User data returned from user lookup service
+ * @since 3.2.0
+ */
+interface UserData {
+    id: string;
+    tenantId?: string;
+    userName: string;
+    name: string;
+    surname: string;
+    email: string;
+    emailConfirmed: boolean;
+    phoneNumber: string;
+    phoneNumberConfirmed: boolean;
+}
+
+/**
+ * Identity User Lookup proxy service for user lookup API calls
+ * Translated from @abp/ng.identity v3.2.0
+ *
+ * @since 3.2.0
+ */
+declare class IdentityUserLookupService {
+    private restService;
     /**
-     * Get users with pagination and filtering
-     * @param params - Query parameters for pagination and filtering
-     * @returns Promise with paginated user response
+     * The API name used for REST requests.
      */
-    getUsers(params?: ABP.PageQueryParams): Promise<Identity.UserResponse>;
+    apiName: string;
+    constructor(restService: RestService);
     /**
-     * Get a user by ID
+     * Find a user by ID
      * @param id - The user ID
-     * @returns Promise with the user item
+     * @returns Promise with the user data
      */
-    getUserById(id: string): Promise<Identity.UserItem>;
+    findById: (id: string) => Promise<UserData>;
     /**
-     * Get roles assigned to a user
-     * @param id - The user ID
-     * @returns Promise with the user's roles
+     * Find a user by username
+     * @param userName - The username to search for
+     * @returns Promise with the user data
      */
-    getUserRoles(id: string): Promise<Identity.RoleResponse>;
+    findByUserName: (userName: string) => Promise<UserData>;
     /**
-     * Get all roles that can be assigned to users.
-     * This returns the list of available roles for user assignment.
-     * @since 3.0.0
-     * @returns Promise with assignable roles
+     * Get count of users matching filter
+     * @param input - Filter parameters
+     * @returns Promise with the count
      */
-    getUserAssignableRoles(): Promise<Identity.RoleResponse>;
+    getCount: (input: UserLookupCountInputDto) => Promise<number>;
     /**
-     * Delete a user
-     * @param id - The user ID to delete
-     * @returns Promise resolving when complete
+     * Search for users
+     * @param input - Search and pagination parameters
+     * @returns Promise with matching users
      */
-    deleteUser(id: string): Promise<void>;
+    search: (input: UserLookupSearchInputDto) => Promise<ListResultDto<UserData>>;
+}
+
+/**
+ * Identity User proxy service for user management API calls
+ * Translated from @abp/ng.identity v3.2.0
+ *
+ * @since 3.2.0
+ */
+declare class IdentityUserService {
+    private restService;
+    /**
+     * The API name used for REST requests.
+     */
+    apiName: string;
+    constructor(restService: RestService);
     /**
      * Create a new user
-     * @param body - The user data to create
+     * @param input - The user data to create
      * @returns Promise with the created user
      */
-    createUser(body: Identity.UserSaveRequest): Promise<Identity.UserItem>;
+    create: (input: IdentityUserCreateDto) => Promise<IdentityUserDto>;
+    /**
+     * Delete a user by ID
+     * @param id - The user ID to delete
+     * @returns Promise that resolves when deletion is complete
+     */
+    delete: (id: string) => Promise<void>;
+    /**
+     * Find a user by email
+     * @param email - The user's email
+     * @returns Promise with the user
+     */
+    findByEmail: (email: string) => Promise<IdentityUserDto>;
+    /**
+     * Find a user by username
+     * @param username - The user's username
+     * @returns Promise with the user
+     */
+    findByUsername: (username: string) => Promise<IdentityUserDto>;
+    /**
+     * Get a user by ID
+     * @param id - The user ID
+     * @returns Promise with the user
+     */
+    get: (id: string) => Promise<IdentityUserDto>;
+    /**
+     * Get all roles that can be assigned to users
+     * @returns Promise with assignable roles
+     */
+    getAssignableRoles: () => Promise<ListResultDto<IdentityRoleDto>>;
+    /**
+     * Get users with pagination and filtering
+     * @param input - Pagination, sorting, and filter parameters
+     * @returns Promise with paginated users
+     */
+    getList: (input: GetIdentityUsersInput) => Promise<PagedResultDto<IdentityUserDto>>;
+    /**
+     * Get roles assigned to a user
+     * @param id - The user ID
+     * @returns Promise with the user's roles
+     */
+    getRoles: (id: string) => Promise<ListResultDto<IdentityRoleDto>>;
     /**
-     * Update an existing user
+     * Update a user
      * @param id - The user ID to update
-     * @param body - The updated user data
+     * @param input - The updated user data
      * @returns Promise with the updated user
      */
-    updateUser(id: string, body: Identity.UserSaveRequest): Promise<Identity.UserItem>;
+    update: (id: string, input: IdentityUserUpdateDto) => Promise<IdentityUserDto>;
+    /**
+     * Update a user's roles
+     * @param id - The user ID
+     * @param input - The new role assignments
+     * @returns Promise that resolves when update is complete
+     */
+    updateRoles: (id: string, input: IdentityUserUpdateRolesDto) => Promise<void>;
+}
+
+/**
+ * Profile proxy service for profile management API calls
+ * Translated from @abp/ng.identity v3.2.0
+ *
+ * @since 3.2.0
+ */
+declare class ProfileService {
+    private restService;
+    /**
+     * The API name used for REST requests.
+     */
+    apiName: string;
+    constructor(restService: RestService);
+    /**
+     * Change the current user's password
+     * @param input - Current and new password
+     * @returns Promise that resolves when password is changed
+     */
+    changePassword: (input: ChangePasswordInput) => Promise<void>;
+    /**
+     * Get the current user's profile
+     * @returns Promise with the profile data
+     */
+    get: () => Promise<ProfileDto>;
+    /**
+     * Update the current user's profile
+     * @param input - Updated profile data
+     * @returns Promise with the updated profile
+     */
+    update: (input: UpdateProfileDto) => Promise<ProfileDto>;
 }
 
 /**
  * IdentityStateService - A stateful service facade for identity operations.
  *
- * This service provides a stateful wrapper around IdentityService, maintaining
+ * This service provides a stateful wrapper around the proxy services, maintaining
  * local state for roles and users. It's the React equivalent of Angular's
  * IdentityStateService which wraps NGXS store operations.
  *
@@ -353,15 +574,17 @@ declare class IdentityService {
  * instead of this class. This class is provided for programmatic/non-hook scenarios.
  *
  * @since 2.0.0
+ * @updated 4.0.0 - Migrated from deprecated IdentityService to IdentityRoleService/IdentityUserService
  *
  * @example
  * ```typescript
- * import { IdentityStateService, IdentityService } from '@abpjs/identity';
+ * import { IdentityStateService, IdentityRoleService, IdentityUserService } from '@abpjs/identity';
  * import { RestService } from '@abpjs/core';
  *
  * const rest = new RestService();
- * const identityService = new IdentityService(rest);
- * const stateService = new IdentityStateService(identityService);
+ * const roleService = new IdentityRoleService(rest);
+ * const userService = new IdentityUserService(rest);
+ * const stateService = new IdentityStateService(roleService, userService);
  *
  * // Fetch and get roles
  * await stateService.dispatchGetRoles();
@@ -369,66 +592,69 @@ declare class IdentityService {
  * ```
  */
 declare class IdentityStateService {
-    private identityService;
+    private identityRoleService;
+    private identityUserService;
     private roles;
     private rolesTotalCount;
     private users;
     private usersTotalCount;
-    constructor(identityService: IdentityService);
+    constructor(identityRoleService: IdentityRoleService, identityUserService: IdentityUserService);
     /**
      * Get the current roles from state
+     * @updated 4.0.0 - Returns IdentityRoleDto[] instead of Identity.RoleItem[]
      */
-    getRoles(): Identity.RoleItem[];
+    getRoles(): IdentityRoleDto[];
     /**
      * Get the total count of roles
      */
     getRolesTotalCount(): number;
     /**
      * Get the current users from state
+     * @updated 4.0.0 - Returns IdentityUserDto[] instead of Identity.UserItem[]
      */
-    getUsers(): Identity.UserItem[];
+    getUsers(): IdentityUserDto[];
     /**
      * Get the total count of users
      */
     getUsersTotalCount(): number;
     /**
      * Fetch roles and update internal state
-     * @param params - Optional query parameters for pagination/filtering
+     * @param params - Optional pagination/sorting parameters
      */
-    dispatchGetRoles(params?: ABP.PageQueryParams): Promise<Identity.RoleResponse>;
+    dispatchGetRoles(params?: PagedAndSortedResultRequestDto): Promise<PagedResultDto<IdentityRoleDto>>;
     /**
      * Fetch a role by ID
      * @param id - The role ID
      */
-    dispatchGetRoleById(id: string): Promise<Identity.RoleItem>;
+    dispatchGetRoleById(id: string): Promise<IdentityRoleDto>;
     /**
      * Delete a role and refresh the list
      * @param id - The role ID to delete
      */
-    dispatchDeleteRole(id: string): Promise<Identity.RoleItem>;
+    dispatchDeleteRole(id: string): Promise<void>;
     /**
      * Create a new role and refresh the list
      * @param body - The role data to create
      */
-    dispatchCreateRole(body: Identity.RoleSaveRequest): Promise<Identity.RoleItem>;
+    dispatchCreateRole(body: IdentityRoleCreateDto): Promise<IdentityRoleDto>;
     /**
      * Update an existing role and refresh the list
      * @param payload - Object containing id and updated role data
      */
     dispatchUpdateRole(payload: {
         id: string;
-        body: Identity.RoleSaveRequest;
-    }): Promise<Identity.RoleItem>;
+        body: IdentityRoleUpdateDto;
+    }): Promise<IdentityRoleDto>;
     /**
      * Fetch users and update internal state
      * @param params - Optional query parameters for pagination/filtering
      */
-    dispatchGetUsers(params?: ABP.PageQueryParams): Promise<Identity.UserResponse>;
+    dispatchGetUsers(params?: GetIdentityUsersInput): Promise<PagedResultDto<IdentityUserDto>>;
     /**
      * Fetch a user by ID
      * @param id - The user ID
      */
-    dispatchGetUserById(id: string): Promise<Identity.UserItem>;
+    dispatchGetUserById(id: string): Promise<IdentityUserDto>;
     /**
      * Delete a user and refresh the list
      * @param id - The user ID to delete
@@ -438,20 +664,20 @@ declare class IdentityStateService {
      * Create a new user and refresh the list
      * @param body - The user data to create
      */
-    dispatchCreateUser(body: Identity.UserSaveRequest): Promise<Identity.UserItem>;
+    dispatchCreateUser(body: IdentityUserCreateDto): Promise<IdentityUserDto>;
     /**
      * Update an existing user and refresh the list
      * @param payload - Object containing id and updated user data
      */
     dispatchUpdateUser(payload: {
         id: string;
-        body: Identity.UserSaveRequest;
-    }): Promise<Identity.UserItem>;
+        body: IdentityUserUpdateDto;
+    }): Promise<IdentityUserDto>;
     /**
      * Get roles assigned to a user
      * @param id - The user ID
      */
-    dispatchGetUserRoles(id: string): Promise<Identity.RoleResponse>;
+    dispatchGetUserRoles(id: string): Promise<ListResultDto<IdentityRoleDto>>;
 }
 
 /**
@@ -468,14 +694,15 @@ interface RoleOperationResult {
 type SortOrder = 'asc' | 'desc' | '';
 /**
  * Return type for useRoles hook
+ * @updated 4.0.0 - Now uses IdentityRoleDto, IdentityRoleCreateDto, IdentityRoleUpdateDto
  */
 interface UseRolesReturn {
     /** List of roles */
-    roles: Identity.RoleItem[];
+    roles: IdentityRoleDto[];
     /** Total count of roles */
     totalCount: number;
     /** Currently selected role for editing */
-    selectedRole: Identity.RoleItem | null;
+    selectedRole: IdentityRoleDto | null;
     /** Loading state */
     isLoading: boolean;
     /** Error message if any */
@@ -485,17 +712,17 @@ interface UseRolesReturn {
     /** Current sort order @since 1.0.0 */
     sortOrder: SortOrder;
     /** Fetch all roles with optional pagination/filtering */
-    fetchRoles: (params?: ABP.PageQueryParams) => Promise<RoleOperationResult>;
+    fetchRoles: (params?: PagedAndSortedResultRequestDto) => 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>;
+    createRole: (role: IdentityRoleCreateDto) => Promise<RoleOperationResult>;
     /** Update an existing role */
-    updateRole: (id: string, role: Identity.RoleSaveRequest) => Promise<RoleOperationResult>;
+    updateRole: (id: string, role: IdentityRoleUpdateDto) => Promise<RoleOperationResult>;
     /** Delete a role */
     deleteRole: (id: string) => Promise<RoleOperationResult>;
     /** Set the selected role */
-    setSelectedRole: (role: Identity.RoleItem | null) => void;
+    setSelectedRole: (role: IdentityRoleDto | null) => void;
     /** Set sort key @since 1.0.0 */
     setSortKey: (key: string) => void;
     /** Set sort order @since 1.0.0 */
@@ -509,6 +736,8 @@ interface UseRolesReturn {
  * This hook provides all the state and actions needed for role management.
  * It handles fetching, creating, updating, and deleting roles.
  *
+ * @updated 4.0.0 - Migrated from deprecated IdentityService to IdentityRoleService
+ *
  * @example
  * ```tsx
  * function RolesPage() {
@@ -524,7 +753,7 @@ interface UseRolesReturn {
  *     fetchRoles();
  *   }, [fetchRoles]);
  *
- *   const handleCreate = async (data: Identity.RoleSaveRequest) => {
+ *   const handleCreate = async (data: IdentityRoleCreateDto) => {
  *     const result = await createRole(data);
  *     if (result.success) {
  *       // Handle success
@@ -552,42 +781,43 @@ interface UserOperationResult {
 }
 /**
  * Return type for useUsers hook
+ * @updated 4.0.0 - Now uses IdentityUserDto, IdentityUserCreateDto, IdentityUserUpdateDto, IdentityRoleDto
  */
 interface UseUsersReturn {
     /** List of users */
-    users: Identity.UserItem[];
+    users: IdentityUserDto[];
     /** Total count of users */
     totalCount: number;
     /** Currently selected user for editing */
-    selectedUser: Identity.UserItem | null;
+    selectedUser: IdentityUserDto | null;
     /** Roles assigned to the selected user */
-    selectedUserRoles: Identity.RoleItem[];
+    selectedUserRoles: IdentityRoleDto[];
     /** Loading state */
     isLoading: boolean;
     /** Error message if any */
     error: string | null;
     /** Current page query parameters */
-    pageQuery: ABP.PageQueryParams;
+    pageQuery: GetIdentityUsersInput;
     /** 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>;
+    fetchUsers: (params?: GetIdentityUsersInput) => 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>;
+    createUser: (user: IdentityUserCreateDto) => Promise<UserOperationResult>;
     /** Update an existing user */
-    updateUser: (id: string, user: Identity.UserSaveRequest) => Promise<UserOperationResult>;
+    updateUser: (id: string, user: IdentityUserUpdateDto) => Promise<UserOperationResult>;
     /** Delete a user */
     deleteUser: (id: string) => Promise<UserOperationResult>;
     /** Set the selected user */
-    setSelectedUser: (user: Identity.UserItem | null) => void;
+    setSelectedUser: (user: IdentityUserDto | null) => void;
     /** Set page query parameters */
-    setPageQuery: (query: ABP.PageQueryParams) => void;
+    setPageQuery: (query: GetIdentityUsersInput) => void;
     /** Set sort key @since 1.0.0 */
     setSortKey: (key: string) => void;
     /** Set sort order @since 1.0.0 */
@@ -601,6 +831,8 @@ interface UseUsersReturn {
  * This hook provides all the state and actions needed for user management.
  * It handles fetching, creating, updating, and deleting users with pagination support.
  *
+ * @updated 4.0.0 - Migrated from deprecated IdentityService to IdentityUserService
+ *
  * @example
  * ```tsx
  * function UsersPage() {
@@ -683,12 +915,13 @@ declare function useIdentity(): UseIdentityReturn;
 
 /**
  * Props for RolesComponent
+ * @updated 4.0.0 - Callbacks now use IdentityRoleDto instead of Identity.RoleItem
  */
 interface RolesComponentProps {
     /** Optional callback when a role is created */
-    onRoleCreated?: (role: Identity.RoleItem) => void;
+    onRoleCreated?: (role: IdentityRoleDto) => void;
     /** Optional callback when a role is updated */
-    onRoleUpdated?: (role: Identity.RoleItem) => void;
+    onRoleUpdated?: (role: IdentityRoleDto) => void;
     /** Optional callback when a role is deleted */
     onRoleDeleted?: (id: string) => void;
     /**
@@ -728,11 +961,14 @@ type PasswordRule = 'number' | 'small' | 'capital' | 'special';
 /**
  * Props for UsersComponent
  */
+/**
+ * @updated 4.0.0 - Callbacks now use IdentityUserDto instead of Identity.UserItem
+ */
 interface UsersComponentProps {
     /** Optional callback when a user is created */
-    onUserCreated?: (user: Identity.UserItem) => void;
+    onUserCreated?: (user: IdentityUserDto) => void;
     /** Optional callback when a user is updated */
-    onUserUpdated?: (user: Identity.UserItem) => void;
+    onUserUpdated?: (user: IdentityUserDto) => void;
     /** Optional callback when a user is deleted */
     onUserDeleted?: (id: string) => void;
     /**
@@ -790,4 +1026,4 @@ declare const IDENTITY_POLICIES: {
     readonly ROLES_DELETE: "AbpIdentity.Roles.Delete";
 };
 
-export { IDENTITY_POLICIES, IDENTITY_ROUTE_PATHS, IDENTITY_ROUTE_PROVIDERS, Identity, type IdentityComponentKey, type IdentityPolicyNameKey, type IdentityRouteNameKey, IdentityService, IdentityStateService, type PasswordRule, type RoleOperationResult, RolesComponent, type RolesComponentProps, type SortOrder, type UseIdentityReturn, type UseRolesReturn, type UseUsersReturn, type UserOperationResult, UsersComponent, type UsersComponentProps, configureRoutes, eIdentityComponents, eIdentityPolicyNames, eIdentityRouteNames, initializeIdentityRoutes, useIdentity, useRoles, useUsers };
+export { type ChangePasswordInput, type GetIdentityUsersInput, IDENTITY_POLICIES, IDENTITY_ROUTE_PATHS, IDENTITY_ROUTE_PROVIDERS, Identity, type IdentityComponentKey, type IdentityPolicyNameKey, type IdentityRoleCreateDto, type IdentityRoleCreateOrUpdateDtoBase, type IdentityRoleDto, IdentityRoleService, type IdentityRoleUpdateDto, type IdentityRouteNameKey, IdentityStateService, type IdentityUserCreateDto, type IdentityUserCreateOrUpdateDtoBase, type IdentityUserDto, IdentityUserLookupService, IdentityUserService, type IdentityUserUpdateDto, type IdentityUserUpdateRolesDto, type PasswordRule, type ProfileDto, ProfileService, type RoleOperationResult, RolesComponent, type RolesComponentProps, type SortOrder, type UpdateProfileDto, type UseIdentityReturn, type UseRolesReturn, type UseUsersReturn, type UserData, type UserLookupCountInputDto, type UserLookupSearchInputDto, type UserOperationResult, UsersComponent, type UsersComponentProps, configureRoutes, eIdentityComponents, eIdentityPolicyNames, eIdentityRouteNames, initializeIdentityRoutes, useIdentity, useRoles, useUsers };