@viridial/shared 1.0.2

package/dist/api/user.service.d.ts

@@ -0,0 +1,86 @@
+import type { User, UserCreate, UserUpdate, UserSearchParams, UserProfile, UserStats, UserActivity } from '../types/user.types';
+/**
+ * Service de gestion des utilisateurs SaaS
+ */
+export declare const userService: {
+    /**
+     * Récupérer tous les utilisateurs avec filtres et pagination
+     */
+    getAll(params?: UserSearchParams): Promise<{
+        users: User[];
+        total: number;
+    }>;
+    /**
+     * Récupérer un utilisateur par ID
+     */
+    getById(id: number): Promise<User>;
+    /**
+     * Récupérer le profil de l'utilisateur connecté
+     */
+    getProfile(): Promise<UserProfile>;
+    /**
+     * Créer un nouvel utilisateur
+     */
+    create(data: UserCreate): Promise<User>;
+    /**
+     * Mettre à jour un utilisateur
+     */
+    update(id: number, data: UserUpdate): Promise<User>;
+    /**
+     * Mettre à jour le profil de l'utilisateur connecté
+     */
+    updateProfile(data: UserUpdate): Promise<UserProfile>;
+    /**
+     * Supprimer un utilisateur (soft delete)
+     */
+    delete(id: number): Promise<void>;
+    /**
+     * Activer un utilisateur
+     */
+    activate(id: number): Promise<User>;
+    /**
+     * Désactiver un utilisateur
+     */
+    deactivate(id: number): Promise<User>;
+    /**
+     * Suspendre un utilisateur
+     */
+    suspend(id: number, reason?: string): Promise<User>;
+    /**
+     * Réinitialiser le mot de passe d'un utilisateur
+     */
+    resetPassword(id: number, newPassword: string): Promise<void>;
+    /**
+     * Changer le mot de passe de l'utilisateur connecté
+     */
+    changePassword(currentPassword: string, newPassword: string): Promise<void>;
+    /**
+     * Vérifier l'email d'un utilisateur
+     */
+    verifyEmail(token: string): Promise<void>;
+    /**
+     * Renvoyer l'email de vérification
+     */
+    resendVerificationEmail(): Promise<void>;
+    /**
+     * Récupérer les statistiques des utilisateurs
+     */
+    getStats(): Promise<UserStats>;
+    /**
+     * Récupérer l'activité d'un utilisateur
+     */
+    getActivity(userId: number, limit?: number): Promise<UserActivity[]>;
+    /**
+     * Rechercher des utilisateurs
+     */
+    search(query: string, params?: UserSearchParams): Promise<User[]>;
+    /**
+     * Assigner des rôles à un utilisateur
+     */
+    assignRoles(userId: number, roles: string[]): Promise<User>;
+    /**
+     * Retirer des rôles d'un utilisateur
+     */
+    removeRoles(userId: number, roles: string[]): Promise<User>;
+};
+//# sourceMappingURL=user.service.d.ts.map

package/dist/api/user.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.service.d.ts","sourceRoot":"","sources":["../../api/user.service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,WAAW,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAG/H;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB;;OAEG;oBACmB,gBAAgB,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAWlF;;OAEG;gBACe,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKxC;;OAEG;kBACiB,OAAO,CAAC,WAAW,CAAC;IAKxC;;OAEG;iBACgB,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7C;;OAEG;eACc,MAAM,QAAQ,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzD;;OAEG;wBACuB,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC;IAK3D;;OAEG;eACc,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC;;OAEG;iBACgB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzC;;OAEG;mBACkB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3C;;OAEG;gBACe,MAAM,WAAW,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzD;;OAEG;sBACqB,MAAM,eAAe,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAInE;;OAEG;oCACmC,MAAM,eAAe,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOjF;;OAEG;uBACsB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/C;;OAEG;+BAC8B,OAAO,CAAC,IAAI,CAAC;IAI9C;;OAEG;gBACe,OAAO,CAAC,SAAS,CAAC;IAKpC;;OAEG;wBACuB,MAAM,UAAU,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAQ1E;;OAEG;kBACiB,MAAM,WAAW,gBAAgB,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAOvE;;OAEG;wBACuB,MAAM,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjE;;OAEG;wBACuB,MAAM,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAMlE,CAAA"}

package/dist/api/user.service.js

@@ -0,0 +1,145 @@
+import { httpClient } from './http.client';
+import { API_ENDPOINTS } from '../constants/api.constants';
+/**
+ * Service de gestion des utilisateurs SaaS
+ */
+export const userService = {
+    /**
+     * Récupérer tous les utilisateurs avec filtres et pagination
+     */
+    async getAll(params) {
+        const response = await httpClient.get(API_ENDPOINTS.USERS.BASE, { params });
+        return {
+            users: response.data?.content || response.data || [],
+            total: response.data?.totalElements || 0
+        };
+    },
+    /**
+     * Récupérer un utilisateur par ID
+     */
+    async getById(id) {
+        const response = await httpClient.get(API_ENDPOINTS.USERS.BY_ID(id));
+        return response.data;
+    },
+    /**
+     * Récupérer le profil de l'utilisateur connecté
+     */
+    async getProfile() {
+        const response = await httpClient.get(API_ENDPOINTS.USERS.PROFILE);
+        return response.data;
+    },
+    /**
+     * Créer un nouvel utilisateur
+     */
+    async create(data) {
+        const response = await httpClient.post(API_ENDPOINTS.USERS.BASE, data);
+        return response.data;
+    },
+    /**
+     * Mettre à jour un utilisateur
+     */
+    async update(id, data) {
+        const response = await httpClient.put(API_ENDPOINTS.USERS.BY_ID(id), data);
+        return response.data;
+    },
+    /**
+     * Mettre à jour le profil de l'utilisateur connecté
+     */
+    async updateProfile(data) {
+        const response = await httpClient.put(API_ENDPOINTS.USERS.PROFILE, data);
+        return response.data;
+    },
+    /**
+     * Supprimer un utilisateur (soft delete)
+     */
+    async delete(id) {
+        await httpClient.delete(API_ENDPOINTS.USERS.BY_ID(id));
+    },
+    /**
+     * Activer un utilisateur
+     */
+    async activate(id) {
+        const response = await httpClient.patch(`${API_ENDPOINTS.USERS.BY_ID(id)}/activate`);
+        return response.data;
+    },
+    /**
+     * Désactiver un utilisateur
+     */
+    async deactivate(id) {
+        const response = await httpClient.patch(`${API_ENDPOINTS.USERS.BY_ID(id)}/deactivate`);
+        return response.data;
+    },
+    /**
+     * Suspendre un utilisateur
+     */
+    async suspend(id, reason) {
+        const response = await httpClient.patch(`${API_ENDPOINTS.USERS.BY_ID(id)}/suspend`, { reason });
+        return response.data;
+    },
+    /**
+     * Réinitialiser le mot de passe d'un utilisateur
+     */
+    async resetPassword(id, newPassword) {
+        await httpClient.post(`${API_ENDPOINTS.USERS.BY_ID(id)}/reset-password`, { password: newPassword });
+    },
+    /**
+     * Changer le mot de passe de l'utilisateur connecté
+     */
+    async changePassword(currentPassword, newPassword) {
+        await httpClient.post(`${API_ENDPOINTS.USERS.PROFILE}/change-password`, {
+            currentPassword,
+            newPassword
+        });
+    },
+    /**
+     * Vérifier l'email d'un utilisateur
+     */
+    async verifyEmail(token) {
+        await httpClient.post(`${API_ENDPOINTS.USERS.PROFILE}/verify-email`, { token });
+    },
+    /**
+     * Renvoyer l'email de vérification
+     */
+    async resendVerificationEmail() {
+        await httpClient.post(`${API_ENDPOINTS.USERS.PROFILE}/resend-verification`);
+    },
+    /**
+     * Récupérer les statistiques des utilisateurs
+     */
+    async getStats() {
+        const response = await httpClient.get(`${API_ENDPOINTS.USERS.BASE}/stats`);
+        return response.data;
+    },
+    /**
+     * Récupérer l'activité d'un utilisateur
+     */
+    async getActivity(userId, limit) {
+        const response = await httpClient.get(`${API_ENDPOINTS.USERS.BY_ID(userId)}/activity`, { params: { limit } });
+        return response.data || [];
+    },
+    /**
+     * Rechercher des utilisateurs
+     */
+    async search(query, params) {
+        const response = await httpClient.get(`${API_ENDPOINTS.USERS.BASE}/search`, {
+            params: { q: query, ...params }
+        });
+        return response.data || [];
+    },
+    /**
+     * Assigner des rôles à un utilisateur
+     */
+    async assignRoles(userId, roles) {
+        const response = await httpClient.post(`${API_ENDPOINTS.USERS.BY_ID(userId)}/roles`, { roles });
+        return response.data;
+    },
+    /**
+     * Retirer des rôles d'un utilisateur
+     */
+    async removeRoles(userId, roles) {
+        const response = await httpClient.delete(`${API_ENDPOINTS.USERS.BY_ID(userId)}/roles`, {
+            data: { roles }
+        });
+        return response.data;
+    }
+};

package/dist/composables/useAuth.d.ts

@@ -0,0 +1,21 @@
+import type { LoginRequest } from '../types/auth.types';
+/**
+ * Composable pour l'authentification
+ */
+export declare function useAuth(): {
+    user: import("vue").ComputedRef<{
+        id: number;
+        email: string;
+        name: string;
+        roles?: string[] | undefined;
+        organizationId?: number | undefined;
+    } | null>;
+    isAuthenticated: import("vue").ComputedRef<boolean>;
+    isLoading: import("vue").ComputedRef<boolean>;
+    isAdmin: import("vue").ComputedRef<boolean>;
+    isAgent: import("vue").ComputedRef<boolean>;
+    login: (credentials: LoginRequest) => Promise<void>;
+    logout: () => Promise<void>;
+    requireAuth: () => void;
+};
+//# sourceMappingURL=useAuth.d.ts.map

package/dist/composables/useAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../composables/useAuth.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAEvD;;GAEG;AACH,wBAAgB,OAAO;;;;;;;;;;;;yBAUa,YAAY;;;EA8B/C"}

package/dist/composables/useAuth.js

@@ -0,0 +1,43 @@
+import { computed } from 'vue';
+import { useRouter } from 'vue-router';
+import { useAuthStore } from '../stores/auth.store';
+/**
+ * Composable pour l'authentification
+ */
+export function useAuth() {
+    const router = useRouter();
+    const authStore = useAuthStore();
+    const user = computed(() => authStore.user);
+    const isAuthenticated = computed(() => authStore.isAuthenticated);
+    const isLoading = computed(() => authStore.loading);
+    const isAdmin = computed(() => authStore.isAdmin);
+    const isAgent = computed(() => authStore.isAgent);
+    async function login(credentials) {
+        try {
+            await authStore.login(credentials);
+            router.push('/');
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async function logout() {
+        await authStore.logout();
+        router.push('/login');
+    }
+    function requireAuth() {
+        if (!authStore.isAuthenticated) {
+            router.push('/login');
+        }
+    }
+    return {
+        user,
+        isAuthenticated,
+        isLoading,
+        isAdmin,
+        isAgent,
+        login,
+        logout,
+        requireAuth
+    };
+}

package/dist/composables/useUser.d.ts

@@ -0,0 +1,173 @@
+import type { User, UserCreate, UserUpdate, UserSearchParams } from '../types/user.types';
+import { UserRole, UserStatus } from '../types/user.types';
+/**
+ * Composable pour la gestion des utilisateurs
+ */
+export declare function useUser(): {
+    users: import("vue").ComputedRef<{
+        id: number;
+        email: string;
+        name: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        phone?: string | undefined;
+        avatar?: string | undefined;
+        status: UserStatus;
+        roles: UserRole[];
+        organizationId?: number | undefined;
+        organizationName?: string | undefined;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | undefined;
+        emailVerified: boolean;
+        metadata?: Record<string, any> | undefined;
+    }[]>;
+    currentUser: import("vue").ComputedRef<{
+        preferences?: {
+            language: string;
+            timezone: string;
+            theme: "light" | "dark" | "auto";
+            emailNotifications: boolean;
+        } | undefined;
+        notifications?: {
+            email: boolean;
+            push: boolean;
+            sms: boolean;
+            marketing: boolean;
+        } | undefined;
+        id: number;
+        email: string;
+        name: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        phone?: string | undefined;
+        avatar?: string | undefined;
+        status: UserStatus;
+        roles: UserRole[];
+        organizationId?: number | undefined;
+        organizationName?: string | undefined;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | undefined;
+        emailVerified: boolean;
+        metadata?: Record<string, any> | undefined;
+    } | null>;
+    selectedUser: import("vue").ComputedRef<{
+        id: number;
+        email: string;
+        name: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        phone?: string | undefined;
+        avatar?: string | undefined;
+        status: UserStatus;
+        roles: UserRole[];
+        organizationId?: number | undefined;
+        organizationName?: string | undefined;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | undefined;
+        emailVerified: boolean;
+        metadata?: Record<string, any> | undefined;
+    } | null>;
+    stats: import("vue").ComputedRef<{
+        totalUsers: number;
+        activeUsers: number;
+        newUsersThisMonth: number;
+        usersByRole: {
+            SUPER_ADMIN: number;
+            ADMIN: number;
+            AGENT: number;
+            FREELANCE: number;
+            AUTO_ENTREPRENEUR: number;
+            PARTICULAR: number;
+            USER: number;
+        };
+        usersByStatus: {
+            ACTIVE: number;
+            INACTIVE: number;
+            SUSPENDED: number;
+            PENDING: number;
+            DELETED: number;
+        };
+    } | null>;
+    loading: import("vue").ComputedRef<boolean>;
+    total: import("vue").ComputedRef<number>;
+    currentPage: import("vue").ComputedRef<number>;
+    pageSize: import("vue").ComputedRef<number>;
+    activeUsers: import("vue").ComputedRef<{
+        id: number;
+        email: string;
+        name: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        phone?: string | undefined;
+        avatar?: string | undefined;
+        status: UserStatus;
+        roles: UserRole[];
+        organizationId?: number | undefined;
+        organizationName?: string | undefined;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | undefined;
+        emailVerified: boolean;
+        metadata?: Record<string, any> | undefined;
+    }[]>;
+    inactiveUsers: import("vue").ComputedRef<{
+        id: number;
+        email: string;
+        name: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        phone?: string | undefined;
+        avatar?: string | undefined;
+        status: UserStatus;
+        roles: UserRole[];
+        organizationId?: number | undefined;
+        organizationName?: string | undefined;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | undefined;
+        emailVerified: boolean;
+        metadata?: Record<string, any> | undefined;
+    }[]>;
+    suspendedUsers: import("vue").ComputedRef<{
+        id: number;
+        email: string;
+        name: string;
+        firstName?: string | undefined;
+        lastName?: string | undefined;
+        phone?: string | undefined;
+        avatar?: string | undefined;
+        status: UserStatus;
+        roles: UserRole[];
+        organizationId?: number | undefined;
+        organizationName?: string | undefined;
+        createdAt: string;
+        updatedAt: string;
+        lastLoginAt?: string | undefined;
+        emailVerified: boolean;
+        metadata?: Record<string, any> | undefined;
+    }[]>;
+    usersByRole: import("vue").ComputedRef<Record<UserRole, User[]>>;
+    loadUsers: (params?: UserSearchParams) => Promise<void>;
+    loadUser: (id: number) => Promise<void>;
+    loadProfile: () => Promise<void>;
+    createUser: (data: UserCreate) => Promise<User>;
+    updateUser: (id: number, data: UserUpdate) => Promise<User>;
+    updateProfile: (data: UserUpdate) => Promise<import("..").UserProfile>;
+    deleteUser: (id: number) => Promise<void>;
+    activateUser: (id: number) => Promise<User>;
+    deactivateUser: (id: number) => Promise<User>;
+    suspendUser: (id: number, reason?: string) => Promise<User>;
+    loadStats: () => Promise<void>;
+    setPage: (page: number) => void;
+    setPageSize: (size: number) => void;
+    selectUser: (user: User | null) => void;
+    hasRole: (userId: number, role: UserRole) => boolean;
+    isCurrentUser: (userId: number) => boolean;
+    canEditUser: (userId: number) => boolean;
+    canDeleteUser: (userId: number) => boolean;
+    canManageRoles: (userId: number) => boolean;
+};
+//# sourceMappingURL=useUser.d.ts.map

package/dist/composables/useUser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUser.d.ts","sourceRoot":"","sources":["../../composables/useUser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACzF,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAE1D;;GAEG;AACH,wBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAqBa,gBAAgB;mBAItB,MAAM;;uBAQF,UAAU,KAAG,OAAO,CAAC,IAAI,CAAC;qBAI5B,MAAM,QAAQ,UAAU,KAAG,OAAO,CAAC,IAAI,CAAC;0BAInC,UAAU;qBAIf,MAAM;uBAIJ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;yBAIpB,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;sBAIzB,MAAM,WAAW,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;;oBAQ/C,MAAM;wBAIF,MAAM;uBAIP,IAAI,GAAG,IAAI;sBAIZ,MAAM,QAAQ,QAAQ,KAAG,OAAO;4BAI1B,MAAM,KAAG,OAAO;0BAIlB,MAAM,KAAG,OAAO;4BAUd,MAAM,KAAG,OAAO;6BAOf,MAAM,KAAG,OAAO;EA0CjD"}

package/dist/composables/useUser.js

@@ -0,0 +1,132 @@
+import { computed } from 'vue';
+import { useRouter } from 'vue-router';
+import { useUserStore } from '../stores/user.store';
+import { UserRole } from '../types/user.types';
+/**
+ * Composable pour la gestion des utilisateurs
+ */
+export function useUser() {
+    const router = useRouter();
+    const userStore = useUserStore();
+    // State
+    const users = computed(() => userStore.users);
+    const currentUser = computed(() => userStore.currentUser);
+    const selectedUser = computed(() => userStore.selectedUser);
+    const stats = computed(() => userStore.stats);
+    const loading = computed(() => userStore.loading);
+    const total = computed(() => userStore.total);
+    const currentPage = computed(() => userStore.currentPage);
+    const pageSize = computed(() => userStore.pageSize);
+    // Getters
+    const activeUsers = computed(() => userStore.activeUsers);
+    const inactiveUsers = computed(() => userStore.inactiveUsers);
+    const suspendedUsers = computed(() => userStore.suspendedUsers);
+    const usersByRole = computed(() => userStore.usersByRole);
+    // Actions
+    async function loadUsers(params) {
+        await userStore.fetchUsers(params);
+    }
+    async function loadUser(id) {
+        await userStore.fetchUserById(id);
+    }
+    async function loadProfile() {
+        await userStore.fetchProfile();
+    }
+    async function createUser(data) {
+        return await userStore.createUser(data);
+    }
+    async function updateUser(id, data) {
+        return await userStore.updateUser(id, data);
+    }
+    async function updateProfile(data) {
+        return await userStore.updateProfile(data);
+    }
+    async function deleteUser(id) {
+        await userStore.deleteUser(id);
+    }
+    async function activateUser(id) {
+        return await userStore.activateUser(id);
+    }
+    async function deactivateUser(id) {
+        return await userStore.deactivateUser(id);
+    }
+    async function suspendUser(id, reason) {
+        return await userStore.suspendUser(id, reason);
+    }
+    async function loadStats() {
+        await userStore.fetchStats();
+    }
+    function setPage(page) {
+        userStore.setPage(page);
+    }
+    function setPageSize(size) {
+        userStore.setPageSize(size);
+    }
+    function selectUser(user) {
+        userStore.setSelectedUser(user);
+    }
+    function hasRole(userId, role) {
+        return userStore.hasRole(userId, role);
+    }
+    function isCurrentUser(userId) {
+        return userStore.isCurrentUser(userId);
+    }
+    function canEditUser(userId) {
+        // Un utilisateur peut éditer son propre profil ou être admin
+        if (isCurrentUser(userId))
+            return true;
+        if (currentUser.value?.roles.includes(UserRole.ADMIN) ||
+            currentUser.value?.roles.includes(UserRole.SUPER_ADMIN)) {
+            return true;
+        }
+        return false;
+    }
+    function canDeleteUser(userId) {
+        // Seuls les admins peuvent supprimer, et pas leur propre compte
+        if (isCurrentUser(userId))
+            return false;
+        return currentUser.value?.roles.includes(UserRole.ADMIN) ||
+            currentUser.value?.roles.includes(UserRole.SUPER_ADMIN) || false;
+    }
+    function canManageRoles(userId) {
+        // Seuls les super admins peuvent gérer les rôles
+        return currentUser.value?.roles.includes(UserRole.SUPER_ADMIN) || false;
+    }
+    return {
+        // State
+        users,
+        currentUser,
+        selectedUser,
+        stats,
+        loading,
+        total,
+        currentPage,
+        pageSize,
+        // Getters
+        activeUsers,
+        inactiveUsers,
+        suspendedUsers,
+        usersByRole,
+        // Actions
+        loadUsers,
+        loadUser,
+        loadProfile,
+        createUser,
+        updateUser,
+        updateProfile,
+        deleteUser,
+        activateUser,
+        deactivateUser,
+        suspendUser,
+        loadStats,
+        setPage,
+        setPageSize,
+        selectUser,
+        // Permissions
+        hasRole,
+        isCurrentUser,
+        canEditUser,
+        canDeleteUser,
+        canManageRoles
+    };
+}

package/dist/constants/api.constants.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Constantes pour les endpoints API
+ */
+export declare const API_ENDPOINTS: {
+    readonly AUTH: {
+        readonly LOGIN: "/identity/auth/login";
+        readonly REGISTER: "/identity/auth/register";
+        readonly LOGOUT: "/identity/auth/logout";
+        readonly REFRESH: "/identity/auth/refresh";
+        readonly FORGOT_PASSWORD: "/identity/auth/forgot-password";
+        readonly RESET_PASSWORD: "/identity/auth/reset-password";
+    };
+    readonly PROPERTIES: {
+        readonly BASE: "/property-service/api/properties";
+        readonly SEARCH: "/property-service/api/properties/search";
+        readonly BY_ID: (id: number) => string;
+    };
+    readonly USERS: {
+        readonly BASE: "/identity-service/api/users";
+        readonly BY_ID: (id: number) => string;
+        readonly PROFILE: "/identity-service/api/users/profile";
+        readonly STATS: "/identity-service/api/users/stats";
+        readonly SEARCH: "/identity-service/api/users/search";
+        readonly ACTIVITY: (id: number) => string;
+    };
+    readonly ORGANIZATIONS: {
+        readonly BASE: "/organization-service/api/organizations";
+        readonly BY_ID: (id: number) => string;
+    };
+};
+export declare const API_BASE_URL = "/api";
+//# sourceMappingURL=api.constants.d.ts.map

package/dist/constants/api.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.constants.d.ts","sourceRoot":"","sources":["../../constants/api.constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;6BAcV,MAAM;;;;6BAKN,MAAM;;;;gCAIH,MAAM;;;;6BAKT,MAAM;;CAEZ,CAAA;AAEV,eAAO,MAAM,YAAY,SAAS,CAAA"}

package/dist/constants/api.constants.js

@@ -0,0 +1,35 @@
+/**
+ * Constantes pour les endpoints API
+ */
+export const API_ENDPOINTS = {
+    // Authentication
+    AUTH: {
+        LOGIN: '/identity/auth/login',
+        REGISTER: '/identity/auth/register',
+        LOGOUT: '/identity/auth/logout',
+        REFRESH: '/identity/auth/refresh',
+        FORGOT_PASSWORD: '/identity/auth/forgot-password',
+        RESET_PASSWORD: '/identity/auth/reset-password'
+    },
+    // Properties
+    PROPERTIES: {
+        BASE: '/property-service/api/properties',
+        SEARCH: '/property-service/api/properties/search',
+        BY_ID: (id) => `/property-service/api/properties/${id}`
+    },
+    // Users
+    USERS: {
+        BASE: '/identity-service/api/users',
+        BY_ID: (id) => `/identity-service/api/users/${id}`,
+        PROFILE: '/identity-service/api/users/profile',
+        STATS: '/identity-service/api/users/stats',
+        SEARCH: '/identity-service/api/users/search',
+        ACTIVITY: (id) => `/identity-service/api/users/${id}/activity`
+    },
+    // Organizations
+    ORGANIZATIONS: {
+        BASE: '/organization-service/api/organizations',
+        BY_ID: (id) => `/organization-service/api/organizations/${id}`
+    }
+};
+export const API_BASE_URL = '/api';