@en-solutions/tgm-client-sdk 1.6.21

package/esm2022/lib/services/api/warranty.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class WarrantyContractService extends BaseCrudService {
+    resourcePath = '/api/warranties';
+    constructor(http) {
+        super(http);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WarrantyContractService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WarrantyContractService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WarrantyContractService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+export class WarrantyClaimService extends BaseCrudService {
+    resourcePath = '/api/warranty-claims';
+    constructor(http) {
+        super(http);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WarrantyClaimService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WarrantyClaimService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WarrantyClaimService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2FycmFudHkuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvYXBpL3dhcnJhbnR5LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0scUJBQXFCLENBQUM7OztBQUl0RCxNQUFNLE9BQU8sdUJBQXdCLFNBQVEsZUFBaUM7SUFDbEUsWUFBWSxHQUFHLGlCQUFpQixDQUFDO0lBRTNDLFlBQVksSUFBbUI7UUFDN0IsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2QsQ0FBQzt3R0FMVSx1QkFBdUI7NEdBQXZCLHVCQUF1QixjQURWLE1BQU07OzRGQUNuQix1QkFBdUI7a0JBRG5DLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFOztBQVVsQyxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsZUFBOEI7SUFDNUQsWUFBWSxHQUFHLHNCQUFzQixDQUFDO0lBRWhELFlBQVksSUFBbUI7UUFDN0IsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2QsQ0FBQzt3R0FMVSxvQkFBb0I7NEdBQXBCLG9CQUFvQixjQURQLE1BQU07OzRGQUNuQixvQkFBb0I7a0JBRGhDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVGdtSHR0cENsaWVudCB9IGZyb20gJy4uLy4uL2NvcmUvaHR0cC1jbGllbnQuc2VydmljZSc7XG5pbXBvcnQgeyBCYXNlQ3J1ZFNlcnZpY2UgfSBmcm9tICcuL2Jhc2UtY3J1ZC5zZXJ2aWNlJztcbmltcG9ydCB7IFdhcnJhbnR5Q29udHJhY3QsIFdhcnJhbnR5Q2xhaW0gfSBmcm9tICcuLi8uLi9tb2RlbHMvYXBpL3dhcnJhbnR5Lm1vZGVscyc7XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgV2FycmFudHlDb250cmFjdFNlcnZpY2UgZXh0ZW5kcyBCYXNlQ3J1ZFNlcnZpY2U8V2FycmFudHlDb250cmFjdD4ge1xuICBwcm90ZWN0ZWQgcmVzb3VyY2VQYXRoID0gJy9hcGkvd2FycmFudGllcyc7XG5cbiAgY29uc3RydWN0b3IoaHR0cDogVGdtSHR0cENsaWVudCkge1xuICAgIHN1cGVyKGh0dHApO1xuICB9XG59XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgV2FycmFudHlDbGFpbVNlcnZpY2UgZXh0ZW5kcyBCYXNlQ3J1ZFNlcnZpY2U8V2FycmFudHlDbGFpbT4ge1xuICBwcm90ZWN0ZWQgcmVzb3VyY2VQYXRoID0gJy9hcGkvd2FycmFudHktY2xhaW1zJztcblxuICBjb25zdHJ1Y3RvcihodHRwOiBUZ21IdHRwQ2xpZW50KSB7XG4gICAgc3VwZXIoaHR0cCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/services/api/work-order.service.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+/**
+ * WorkOrderService — alias for MaintenanceRecordService.
+ * Work Orders were migrated to Maintenance Records in the backend.
+ * This service provides backward compatibility + custom query methods.
+ */
+export class WorkOrderService extends BaseCrudService {
+    resourcePath = '/api/maintenance-records';
+    constructor(http) {
+        super(http);
+    }
+    getByUnit(unitId) {
+        return this.getAll({ 'unit.id': String(unitId) });
+    }
+    getByStatus(status) {
+        return this.getAll({ status });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WorkOrderService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WorkOrderService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WorkOrderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/api/work-permit.service.mjs

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class WorkPermitService extends BaseCrudService {
+    resourcePath = '/api/work-permits';
+    constructor(http) {
+        super(http);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WorkPermitService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WorkPermitService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WorkPermitService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29yay1wZXJtaXQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvYXBpL3dvcmstcGVybWl0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0scUJBQXFCLENBQUM7OztBQUl0RCxNQUFNLE9BQU8saUJBQWtCLFNBQVEsZUFBMkI7SUFDdEQsWUFBWSxHQUFHLG1CQUFtQixDQUFDO0lBRTdDLFlBQVksSUFBbUI7UUFDN0IsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2QsQ0FBQzt3R0FMVSxpQkFBaUI7NEdBQWpCLGlCQUFpQixjQURKLE1BQU07OzRGQUNuQixpQkFBaUI7a0JBRDdCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVGdtSHR0cENsaWVudCB9IGZyb20gJy4uLy4uL2NvcmUvaHR0cC1jbGllbnQuc2VydmljZSc7XG5pbXBvcnQgeyBCYXNlQ3J1ZFNlcnZpY2UgfSBmcm9tICcuL2Jhc2UtY3J1ZC5zZXJ2aWNlJztcbmltcG9ydCB7IFdvcmtQZXJtaXQgfSBmcm9tICcuLi8uLi9tb2RlbHMvYXBpL3dvcmstcGVybWl0Lm1vZGVscyc7XG5cbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXG5leHBvcnQgY2xhc3MgV29ya1Blcm1pdFNlcnZpY2UgZXh0ZW5kcyBCYXNlQ3J1ZFNlcnZpY2U8V29ya1Blcm1pdD4ge1xuICBwcm90ZWN0ZWQgcmVzb3VyY2VQYXRoID0gJy9hcGkvd29yay1wZXJtaXRzJztcblxuICBjb25zdHJ1Y3RvcihodHRwOiBUZ21IdHRwQ2xpZW50KSB7XG4gICAgc3VwZXIoaHR0cCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/services/api/workflow.service.mjs

@@ -0,0 +1,86 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class ApprovalWorkflowService {
+    http;
+    basePath = '/workflows';
+    constructor(http) {
+        this.http = http;
+    }
+    create(data) {
+        return this.http.post(this.basePath, data);
+    }
+    getById(id) {
+        return this.http.get(`${this.basePath}/${id}`);
+    }
+    getSteps(id) {
+        return this.http.get(`${this.basePath}/${id}/steps`);
+    }
+    approve(id) {
+        return this.http.post(`${this.basePath}/${id}/approve`);
+    }
+    reject(id) {
+        return this.http.post(`${this.basePath}/${id}/reject`);
+    }
+    requestInfo(id) {
+        return this.http.post(`${this.basePath}/${id}/request-info`);
+    }
+    delegate(id, body) {
+        return this.http.post(`${this.basePath}/${id}/delegate`, body);
+    }
+    escalate(id) {
+        return this.http.post(`${this.basePath}/${id}/escalate`);
+    }
+    cancel(id) {
+        return this.http.post(`${this.basePath}/${id}/cancel`);
+    }
+    getMyPending() {
+        return this.http.get(`${this.basePath}/my-pending`);
+    }
+    getMyRequests() {
+        return this.http.get(`${this.basePath}/my-requests`);
+    }
+    getByStatus(status) {
+        return this.http.get(`${this.basePath}/by-status`, {
+            params: { status },
+        });
+    }
+    getByType(type) {
+        return this.http.get(`${this.basePath}/by-type`, {
+            params: { type },
+        });
+    }
+    getByEntity(entityType, entityId) {
+        return this.http.get(`${this.basePath}/by-entity`, {
+            params: { entityType, entityId },
+        });
+    }
+    getEscalated() {
+        return this.http.get(`${this.basePath}/escalated`);
+    }
+    getOverdue() {
+        return this.http.get(`${this.basePath}/overdue`);
+    }
+    getDashboard() {
+        return this.http.get(`${this.basePath}/dashboard`);
+    }
+    getEscalationRules() {
+        return this.http.get(`${this.basePath}/escalation-rules`);
+    }
+    createEscalationRule(data) {
+        return this.http.post(`${this.basePath}/escalation-rules`, data);
+    }
+    updateEscalationRule(id, data) {
+        return this.http.patch(`${this.basePath}/escalation-rules/${id}`, data);
+    }
+    deleteEscalationRule(id) {
+        return this.http.delete(`${this.basePath}/escalation-rules/${id}`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApprovalWorkflowService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApprovalWorkflowService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ApprovalWorkflowService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/api/workflow.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { TgmHttpClient } from '../../core/http-client.service';\nimport { ApiResponse, PagedResponse } from '../../models/base.models';\nimport { ApprovalWorkflow, ApprovalStep, EscalationRule } from '../../models/api/workflow.models';\n\n@Injectable({ providedIn: 'root' })\nexport class ApprovalWorkflowService {\n  private basePath = '/workflows';\n\n  constructor(private http: TgmHttpClient) {}\n\n  create(data: Partial<ApprovalWorkflow>): Observable<ApiResponse<ApprovalWorkflow>> {\n    return this.http.post<ApiResponse<ApprovalWorkflow>>(this.basePath, data);\n  }\n\n  getById(id: number): Observable<ApiResponse<ApprovalWorkflow>> {\n    return this.http.get<ApiResponse<ApprovalWorkflow>>(`${this.basePath}/${id}`);\n  }\n\n  getSteps(id: number): Observable<ApiResponse<ApprovalStep[]>> {\n    return this.http.get<ApiResponse<ApprovalStep[]>>(`${this.basePath}/${id}/steps`);\n  }\n\n  approve(id: number): Observable<ApiResponse<ApprovalWorkflow>> {\n    return this.http.post<ApiResponse<ApprovalWorkflow>>(`${this.basePath}/${id}/approve`);\n  }\n\n  reject(id: number): Observable<ApiResponse<ApprovalWorkflow>> {\n    return this.http.post<ApiResponse<ApprovalWorkflow>>(`${this.basePath}/${id}/reject`);\n  }\n\n  requestInfo(id: number): Observable<ApiResponse<ApprovalWorkflow>> {\n    return this.http.post<ApiResponse<ApprovalWorkflow>>(`${this.basePath}/${id}/request-info`);\n  }\n\n  delegate(id: number, body: any): Observable<ApiResponse<ApprovalWorkflow>> {\n    return this.http.post<ApiResponse<ApprovalWorkflow>>(`${this.basePath}/${id}/delegate`, body);\n  }\n\n  escalate(id: number): Observable<ApiResponse<ApprovalWorkflow>> {\n    return this.http.post<ApiResponse<ApprovalWorkflow>>(`${this.basePath}/${id}/escalate`);\n  }\n\n  cancel(id: number): Observable<ApiResponse<ApprovalWorkflow>> {\n    return this.http.post<ApiResponse<ApprovalWorkflow>>(`${this.basePath}/${id}/cancel`);\n  }\n\n  getMyPending(): Observable<ApiResponse<ApprovalWorkflow[]>> {\n    return this.http.get<ApiResponse<ApprovalWorkflow[]>>(`${this.basePath}/my-pending`);\n  }\n\n  getMyRequests(): Observable<ApiResponse<ApprovalWorkflow[]>> {\n    return this.http.get<ApiResponse<ApprovalWorkflow[]>>(`${this.basePath}/my-requests`);\n  }\n\n  getByStatus(status: string): Observable<ApiResponse<ApprovalWorkflow[]>> {\n    return this.http.get<ApiResponse<ApprovalWorkflow[]>>(`${this.basePath}/by-status`, {\n      params: { status },\n    });\n  }\n\n  getByType(type: string): Observable<ApiResponse<ApprovalWorkflow[]>> {\n    return this.http.get<ApiResponse<ApprovalWorkflow[]>>(`${this.basePath}/by-type`, {\n      params: { type },\n    });\n  }\n\n  getByEntity(entityType: string, entityId: number): Observable<ApiResponse<ApprovalWorkflow[]>> {\n    return this.http.get<ApiResponse<ApprovalWorkflow[]>>(`${this.basePath}/by-entity`, {\n      params: { entityType, entityId },\n    });\n  }\n\n  getEscalated(): Observable<ApiResponse<ApprovalWorkflow[]>> {\n    return this.http.get<ApiResponse<ApprovalWorkflow[]>>(`${this.basePath}/escalated`);\n  }\n\n  getOverdue(): Observable<ApiResponse<ApprovalWorkflow[]>> {\n    return this.http.get<ApiResponse<ApprovalWorkflow[]>>(`${this.basePath}/overdue`);\n  }\n\n  getDashboard(): Observable<ApiResponse<any>> {\n    return this.http.get<ApiResponse<any>>(`${this.basePath}/dashboard`);\n  }\n\n  getEscalationRules(): Observable<ApiResponse<EscalationRule[]>> {\n    return this.http.get<ApiResponse<EscalationRule[]>>(`${this.basePath}/escalation-rules`);\n  }\n\n  createEscalationRule(data: Partial<EscalationRule>): Observable<ApiResponse<EscalationRule>> {\n    return this.http.post<ApiResponse<EscalationRule>>(`${this.basePath}/escalation-rules`, data);\n  }\n\n  updateEscalationRule(id: number, data: Partial<EscalationRule>): Observable<ApiResponse<EscalationRule>> {\n    return this.http.patch<ApiResponse<EscalationRule>>(`${this.basePath}/escalation-rules/${id}`, data);\n  }\n\n  deleteEscalationRule(id: number): Observable<ApiResponse<void>> {\n    return this.http.delete<ApiResponse<void>>(`${this.basePath}/escalation-rules/${id}`);\n  }\n}\n"]}

package/esm2022/lib/services/auth/auth.service.mjs

@@ -0,0 +1,97 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class AuthService {
+    http;
+    currentUser$ = new BehaviorSubject(null);
+    authenticated$ = new BehaviorSubject(false);
+    user$ = this.currentUser$.asObservable();
+    isAuthenticated$ = this.authenticated$.asObservable();
+    constructor(http) {
+        this.http = http;
+    }
+    login(credentials) {
+        return this.http.post('/auth/local', credentials, { skipAuth: true }).pipe(tap((res) => this.handleAuthResponse(res)));
+    }
+    badgeLogin(credentials) {
+        return this.http.post('/auth/badge', credentials, { skipAuth: true }).pipe(tap((res) => this.handleAuthResponse(res)));
+    }
+    register(data) {
+        return this.http.post('/auth/local/register', data, { skipAuth: true }).pipe(tap((res) => this.handleAuthResponse(res)));
+    }
+    forgotPassword(data) {
+        return this.http.post('/auth/forgot-password', data, { skipAuth: true });
+    }
+    resetPassword(data) {
+        return this.http.post('/auth/reset-password', data, { skipAuth: true });
+    }
+    refreshToken() {
+        const refreshToken = this.http.getRefreshToken();
+        return this.http.post('/auth/refresh-token', null, {
+            skipAuth: true,
+            params: { refreshToken: refreshToken ?? '' },
+        }).pipe(tap((res) => this.handleAuthResponse(res)));
+    }
+    getCurrentUser() {
+        return this.http.get('/auth/me').pipe(tap((res) => {
+            if (res.user) {
+                this.currentUser$.next(res.user);
+            }
+        }));
+    }
+    logout() {
+        this.http.clearTokens();
+        this.currentUser$.next(null);
+        this.authenticated$.next(false);
+    }
+    getToken() {
+        return this.http.getToken();
+    }
+    isAuthenticated() {
+        return this.authenticated$.value;
+    }
+    getUser() {
+        return this.currentUser$.value;
+    }
+    getAnnouncements() {
+        return this.http.get('/auth/announcements', { skipAuth: true });
+    }
+    getSandboxes() {
+        return this.http.get('/auth/sandboxes', { skipAuth: true });
+    }
+    getSandboxesByEmail(email) {
+        return this.http.get('/auth/sandboxes/by-email', { skipAuth: true, params: { email } });
+    }
+    sendVerificationEmail() {
+        return this.http.post('/auth/send-verification');
+    }
+    verifyEmail(token) {
+        return this.http.get('/auth/verify-email', { skipAuth: true, params: { token } });
+    }
+    validateInviteToken(token) {
+        return this.http.get('/auth/accept-invite', { skipAuth: true, params: { token } });
+    }
+    acceptInvite(data) {
+        return this.http.post('/auth/accept-invite', data, { skipAuth: true }).pipe(tap((res) => this.handleAuthResponse(res)));
+    }
+    handleAuthResponse(res) {
+        if (res.jwt) {
+            this.http.setToken(res.jwt);
+        }
+        if (res.refreshToken) {
+            this.http.setRefreshToken(res.refreshToken);
+        }
+        if (res.user) {
+            this.currentUser$.next(res.user);
+            this.authenticated$.next(true);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/auth/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, BehaviorSubject, tap, map } from 'rxjs';\nimport { TgmHttpClient } from '../../core/http-client.service';\nimport {\n  LoginRequest,\n  BadgePinLoginRequest,\n  RegisterRequest,\n  ForgotPasswordRequest,\n  ResetPasswordRequest,\n  AuthResponse,\n  UserDto,\n} from '../../models/auth/login.models';\nimport { ApiResponse } from '../../models/base.models';\n\n@Injectable({ providedIn: 'root' })\nexport class AuthService {\n  private currentUser$ = new BehaviorSubject<UserDto | null>(null);\n  private authenticated$ = new BehaviorSubject<boolean>(false);\n\n  readonly user$ = this.currentUser$.asObservable();\n  readonly isAuthenticated$ = this.authenticated$.asObservable();\n\n  constructor(private http: TgmHttpClient) {}\n\n  login(credentials: LoginRequest): Observable<AuthResponse> {\n    return this.http.post<AuthResponse>('/auth/local', credentials, { skipAuth: true }).pipe(\n      tap((res) => this.handleAuthResponse(res))\n    );\n  }\n\n  badgeLogin(credentials: BadgePinLoginRequest): Observable<AuthResponse> {\n    return this.http.post<AuthResponse>('/auth/badge', credentials, { skipAuth: true }).pipe(\n      tap((res) => this.handleAuthResponse(res))\n    );\n  }\n\n  register(data: RegisterRequest): Observable<AuthResponse> {\n    return this.http.post<AuthResponse>('/auth/local/register', data, { skipAuth: true }).pipe(\n      tap((res) => this.handleAuthResponse(res))\n    );\n  }\n\n  forgotPassword(data: ForgotPasswordRequest): Observable<any> {\n    return this.http.post('/auth/forgot-password', data, { skipAuth: true });\n  }\n\n  resetPassword(data: ResetPasswordRequest): Observable<any> {\n    return this.http.post('/auth/reset-password', data, { skipAuth: true });\n  }\n\n  refreshToken(): Observable<AuthResponse> {\n    const refreshToken = this.http.getRefreshToken();\n    return this.http.post<AuthResponse>('/auth/refresh-token', null, {\n      skipAuth: true,\n      params: { refreshToken: refreshToken ?? '' },\n    }).pipe(\n      tap((res) => this.handleAuthResponse(res))\n    );\n  }\n\n  getCurrentUser(): Observable<AuthResponse> {\n    return this.http.get<AuthResponse>('/auth/me').pipe(\n      tap((res) => {\n        if (res.user) {\n          this.currentUser$.next(res.user);\n        }\n      })\n    );\n  }\n\n  logout(): void {\n    this.http.clearTokens();\n    this.currentUser$.next(null);\n    this.authenticated$.next(false);\n  }\n\n  getToken(): string | null {\n    return this.http.getToken();\n  }\n\n  isAuthenticated(): boolean {\n    return this.authenticated$.value;\n  }\n\n  getUser(): UserDto | null {\n    return this.currentUser$.value;\n  }\n\n  getAnnouncements(): Observable<any[]> {\n    return this.http.get<any[]>('/auth/announcements', { skipAuth: true });\n  }\n\n  getSandboxes(): Observable<any[]> {\n    return this.http.get<any[]>('/auth/sandboxes', { skipAuth: true });\n  }\n\n  getSandboxesByEmail(email: string): Observable<any[]> {\n    return this.http.get<any[]>('/auth/sandboxes/by-email', { skipAuth: true, params: { email } });\n  }\n\n  sendVerificationEmail(): Observable<any> {\n    return this.http.post('/auth/send-verification');\n  }\n\n  verifyEmail(token: string): Observable<any> {\n    return this.http.get('/auth/verify-email', { skipAuth: true, params: { token } });\n  }\n\n  validateInviteToken(token: string): Observable<any> {\n    return this.http.get('/auth/accept-invite', { skipAuth: true, params: { token } });\n  }\n\n  acceptInvite(data: any): Observable<AuthResponse> {\n    return this.http.post<AuthResponse>('/auth/accept-invite', data, { skipAuth: true }).pipe(\n      tap((res) => this.handleAuthResponse(res))\n    );\n  }\n\n  private handleAuthResponse(res: AuthResponse): void {\n    if (res.jwt) {\n      this.http.setToken(res.jwt);\n    }\n    if (res.refreshToken) {\n      this.http.setRefreshToken(res.refreshToken);\n    }\n    if (res.user) {\n      this.currentUser$.next(res.user);\n      this.authenticated$.next(true);\n    }\n  }\n}\n"]}

package/esm2022/lib/services/auth/index.mjs

@@ -0,0 +1,5 @@
+export { AuthService } from './auth.service';
+export { SsoAuthService } from './sso-auth.service';
+export { TotpService } from './totp.service';
+export { PlatformAuthService } from './platform-auth.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2F1dGgvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDN0MsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBBdXRoU2VydmljZSB9IGZyb20gJy4vYXV0aC5zZXJ2aWNlJztcbmV4cG9ydCB7IFNzb0F1dGhTZXJ2aWNlIH0gZnJvbSAnLi9zc28tYXV0aC5zZXJ2aWNlJztcbmV4cG9ydCB7IFRvdHBTZXJ2aWNlIH0gZnJvbSAnLi90b3RwLnNlcnZpY2UnO1xuZXhwb3J0IHsgUGxhdGZvcm1BdXRoU2VydmljZSB9IGZyb20gJy4vcGxhdGZvcm0tYXV0aC5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/services/auth/platform-auth.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class PlatformAuthService {
+    http;
+    currentAdmin$ = new BehaviorSubject(null);
+    admin$ = this.currentAdmin$.asObservable();
+    constructor(http) {
+        this.http = http;
+    }
+    login(credentials) {
+        return this.http.post('/auth/platform/login', credentials, { skipAuth: true }).pipe(tap((res) => {
+            if (res.accessToken) {
+                this.http.setToken(res.accessToken);
+            }
+            if (res.admin) {
+                this.currentAdmin$.next(res.admin);
+            }
+        }));
+    }
+    getCurrentAdmin() {
+        return this.http.get('/auth/platform/me').pipe(tap((admin) => this.currentAdmin$.next(admin)));
+    }
+    logout() {
+        this.http.clearTokens();
+        this.currentAdmin$.next(null);
+    }
+    getAdmin() {
+        return this.currentAdmin$.value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PlatformAuthService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PlatformAuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PlatformAuthService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/auth/sso-auth.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class SsoAuthService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    getProviders() {
+        return this.http.get('/auth/sso/providers', { skipAuth: true });
+    }
+    authorize(request) {
+        return this.http.post('/auth/sso/authorize', request, { skipAuth: true });
+    }
+    handleCallback(providerId, params) {
+        return this.http.get(`/auth/sso/callback/${providerId}`, {
+            skipAuth: true,
+            params: params,
+        });
+    }
+    handleSamlCallback(data) {
+        return this.http.post('/auth/sso/saml/acs', data, { skipAuth: true });
+    }
+    getSamlMetadata() {
+        return this.http.get('/auth/sso/saml/metadata', { skipAuth: true, responseType: 'text' });
+    }
+    linkAccount(request) {
+        return this.http.post('/auth/sso/link', request);
+    }
+    unlinkAccount(providerId) {
+        return this.http.delete(`/auth/sso/link/${providerId}`);
+    }
+    getLinkedAccounts() {
+        return this.http.get('/auth/sso/linked-accounts');
+    }
+    setPrimaryProvider(providerId) {
+        return this.http.post(`/auth/sso/primary-provider/${providerId}`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SsoAuthService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SsoAuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SsoAuthService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/auth/totp.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class TotpService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    getStatus() {
+        return this.http.get('/auth/totp/status');
+    }
+    setup() {
+        return this.http.post('/auth/totp/setup');
+    }
+    verifySetup(data) {
+        return this.http.post('/auth/totp/setup/verify', data);
+    }
+    disable(data) {
+        return this.http.post('/auth/totp/disable', data);
+    }
+    verify(data) {
+        return this.http.post('/auth/totp/verify', data, { skipAuth: true });
+    }
+    regenerateRecoveryCodes() {
+        return this.http.post('/auth/totp/recovery-codes/regenerate');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TotpService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TotpService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TotpService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/chat/chat-rest.service.mjs

@@ -0,0 +1,104 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/http-client.service";
+export class ChatRestService {
+    http;
+    basePath = '/api/chat';
+    constructor(http) {
+        this.http = http;
+    }
+    // --- Conversations ---
+    getConversations(params) {
+        return this.http.get(`${this.basePath}/conversations`, { params: params });
+    }
+    getConversation(id) {
+        return this.http.get(`${this.basePath}/conversations/${id}`);
+    }
+    createConversation(data) {
+        return this.http.post(`${this.basePath}/conversations`, data);
+    }
+    updateConversation(id, data) {
+        return this.http.put(`${this.basePath}/conversations/${id}`, data);
+    }
+    deleteConversation(id) {
+        return this.http.delete(`${this.basePath}/conversations/${id}`);
+    }
+    archiveConversation(id) {
+        return this.http.post(`${this.basePath}/conversations/${id}/archive`);
+    }
+    unarchiveConversation(id) {
+        return this.http.post(`${this.basePath}/conversations/${id}/unarchive`);
+    }
+    muteConversation(id) {
+        return this.http.post(`${this.basePath}/conversations/${id}/mute`);
+    }
+    unmuteConversation(id) {
+        return this.http.post(`${this.basePath}/conversations/${id}/unmute`);
+    }
+    pinConversation(id) {
+        return this.http.post(`${this.basePath}/conversations/${id}/pin`);
+    }
+    unpinConversation(id) {
+        return this.http.post(`${this.basePath}/conversations/${id}/unpin`);
+    }
+    // --- Messages ---
+    getMessages(conversationId, params) {
+        return this.http.get(`${this.basePath}/conversations/${conversationId}/messages`, { params: params });
+    }
+    sendMessage(data) {
+        return this.http.post(`${this.basePath}/messages`, data);
+    }
+    editMessage(messageId, data) {
+        return this.http.put(`${this.basePath}/messages/${messageId}`, data);
+    }
+    deleteMessage(messageId) {
+        return this.http.delete(`${this.basePath}/messages/${messageId}`);
+    }
+    getReplies(messageId, params) {
+        return this.http.get(`${this.basePath}/messages/${messageId}/replies`, { params: params });
+    }
+    searchMessages(conversationId, query) {
+        return this.http.get(`${this.basePath}/conversations/${conversationId}/messages/search`, { params: { query } });
+    }
+    // --- Participants ---
+    getParticipants(conversationId) {
+        return this.http.get(`${this.basePath}/conversations/${conversationId}/participants`);
+    }
+    addParticipants(conversationId, data) {
+        return this.http.post(`${this.basePath}/conversations/${conversationId}/participants`, data);
+    }
+    removeParticipant(conversationId, userId) {
+        return this.http.delete(`${this.basePath}/conversations/${conversationId}/participants/${userId}`);
+    }
+    leaveConversation(conversationId) {
+        return this.http.post(`${this.basePath}/conversations/${conversationId}/leave`);
+    }
+    // --- Reactions ---
+    addReaction(messageId, emoji) {
+        return this.http.post(`${this.basePath}/messages/${messageId}/reactions`, { emoji });
+    }
+    removeReaction(messageId, emoji) {
+        return this.http.delete(`${this.basePath}/messages/${messageId}/reactions`, { params: { emoji } });
+    }
+    // --- Read Receipts ---
+    markAsRead(conversationId, lastMessageId) {
+        return this.http.post(`${this.basePath}/conversations/${conversationId}/read`, {
+            conversationId,
+            lastReadMessageId: lastMessageId,
+        });
+    }
+    // --- Presence ---
+    getPresence() {
+        return this.http.get(`${this.basePath}/presence`);
+    }
+    getUserPresence(userId) {
+        return this.http.get(`${this.basePath}/presence/${userId}`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChatRestService, deps: [{ token: i1.TgmHttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChatRestService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChatRestService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TgmHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat-rest.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/chat/chat-rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { TgmHttpClient } from '../../core/http-client.service';\nimport { ApiResponse, PagedResponse, PaginationParams } from '../../models/base.models';\nimport {\n  Conversation,\n  ChatMessage,\n  ChatParticipant,\n  PresenceResponse,\n  CreateConversationRequest,\n  SendMessageRequest,\n  UpdateConversationRequest,\n  AddParticipantRequest,\n  EditMessageRequest,\n} from '../../models/chat/chat.models';\n\n@Injectable({ providedIn: 'root' })\nexport class ChatRestService {\n  private readonly basePath = '/api/chat';\n\n  constructor(private http: TgmHttpClient) {}\n\n  // --- Conversations ---\n\n  getConversations(params?: PaginationParams & { search?: string }): Observable<PagedResponse<Conversation>> {\n    return this.http.get<PagedResponse<Conversation>>(`${this.basePath}/conversations`, { params: params as any });\n  }\n\n  getConversation(id: number): Observable<ApiResponse<Conversation>> {\n    return this.http.get<ApiResponse<Conversation>>(`${this.basePath}/conversations/${id}`);\n  }\n\n  createConversation(data: CreateConversationRequest): Observable<ApiResponse<Conversation>> {\n    return this.http.post<ApiResponse<Conversation>>(`${this.basePath}/conversations`, data);\n  }\n\n  updateConversation(id: number, data: UpdateConversationRequest): Observable<ApiResponse<Conversation>> {\n    return this.http.put<ApiResponse<Conversation>>(`${this.basePath}/conversations/${id}`, data);\n  }\n\n  deleteConversation(id: number): Observable<ApiResponse<void>> {\n    return this.http.delete<ApiResponse<void>>(`${this.basePath}/conversations/${id}`);\n  }\n\n  archiveConversation(id: number): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${id}/archive`);\n  }\n\n  unarchiveConversation(id: number): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${id}/unarchive`);\n  }\n\n  muteConversation(id: number): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${id}/mute`);\n  }\n\n  unmuteConversation(id: number): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${id}/unmute`);\n  }\n\n  pinConversation(id: number): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${id}/pin`);\n  }\n\n  unpinConversation(id: number): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${id}/unpin`);\n  }\n\n  // --- Messages ---\n\n  getMessages(conversationId: number, params?: PaginationParams): Observable<PagedResponse<ChatMessage>> {\n    return this.http.get<PagedResponse<ChatMessage>>(`${this.basePath}/conversations/${conversationId}/messages`, { params: params as any });\n  }\n\n  sendMessage(data: SendMessageRequest): Observable<ApiResponse<ChatMessage>> {\n    return this.http.post<ApiResponse<ChatMessage>>(`${this.basePath}/messages`, data);\n  }\n\n  editMessage(messageId: number, data: EditMessageRequest): Observable<ApiResponse<ChatMessage>> {\n    return this.http.put<ApiResponse<ChatMessage>>(`${this.basePath}/messages/${messageId}`, data);\n  }\n\n  deleteMessage(messageId: number): Observable<ApiResponse<void>> {\n    return this.http.delete<ApiResponse<void>>(`${this.basePath}/messages/${messageId}`);\n  }\n\n  getReplies(messageId: number, params?: PaginationParams): Observable<PagedResponse<ChatMessage>> {\n    return this.http.get<PagedResponse<ChatMessage>>(`${this.basePath}/messages/${messageId}/replies`, { params: params as any });\n  }\n\n  searchMessages(conversationId: number, query: string): Observable<ChatMessage[]> {\n    return this.http.get<ChatMessage[]>(`${this.basePath}/conversations/${conversationId}/messages/search`, { params: { query } });\n  }\n\n  // --- Participants ---\n\n  getParticipants(conversationId: number): Observable<ChatParticipant[]> {\n    return this.http.get<ChatParticipant[]>(`${this.basePath}/conversations/${conversationId}/participants`);\n  }\n\n  addParticipants(conversationId: number, data: AddParticipantRequest): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${conversationId}/participants`, data);\n  }\n\n  removeParticipant(conversationId: number, userId: number): Observable<ApiResponse<void>> {\n    return this.http.delete<ApiResponse<void>>(`${this.basePath}/conversations/${conversationId}/participants/${userId}`);\n  }\n\n  leaveConversation(conversationId: number): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${conversationId}/leave`);\n  }\n\n  // --- Reactions ---\n\n  addReaction(messageId: number, emoji: string): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/messages/${messageId}/reactions`, { emoji });\n  }\n\n  removeReaction(messageId: number, emoji: string): Observable<ApiResponse<void>> {\n    return this.http.delete<ApiResponse<void>>(`${this.basePath}/messages/${messageId}/reactions`, { params: { emoji } });\n  }\n\n  // --- Read Receipts ---\n\n  markAsRead(conversationId: number, lastMessageId?: number): Observable<ApiResponse<void>> {\n    return this.http.post<ApiResponse<void>>(`${this.basePath}/conversations/${conversationId}/read`, {\n      conversationId,\n      lastReadMessageId: lastMessageId,\n    });\n  }\n\n  // --- Presence ---\n\n  getPresence(): Observable<PresenceResponse[]> {\n    return this.http.get<PresenceResponse[]>(`${this.basePath}/presence`);\n  }\n\n  getUserPresence(userId: number): Observable<PresenceResponse> {\n    return this.http.get<PresenceResponse>(`${this.basePath}/presence/${userId}`);\n  }\n}\n"]}