@en-solutions/tgm-client-sdk 1.6.21

package/lib/services/api/sandbox.service.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare class SandboxService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<ApiResponse<any[]>>;
+    create(data: any): Observable<ApiResponse<any>>;
+    getById(id: number): Observable<ApiResponse<any>>;
+    getBySlug(slug: string): Observable<ApiResponse<any>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    suspend(id: number): Observable<ApiResponse<any>>;
+    activate(id: number): Observable<ApiResponse<any>>;
+    reset(id: number, data?: any): Observable<ApiResponse<any>>;
+    getAccess(id: number): Observable<ApiResponse<any[]>>;
+    grantAccess(id: number, data: any): Observable<ApiResponse<any>>;
+    revokeAccess(id: number, userId: number): Observable<ApiResponse<void>>;
+    generateName(): Observable<ApiResponse<any>>;
+    checkSlug(slug: string): Observable<ApiResponse<any>>;
+    getTemplates(): Observable<ApiResponse<any[]>>;
+    getStats(): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SandboxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SandboxService>;
+}

package/lib/services/api/scheduled-report.service.d.ts

@@ -0,0 +1,10 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ScheduledReport } from '../../models/api/misc.models';
+import * as i0 from "@angular/core";
+export declare class ScheduledReportService extends BaseCrudService<ScheduledReport> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScheduledReportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScheduledReportService>;
+}

package/lib/services/api/search.service.d.ts

@@ -0,0 +1,54 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { SearchRequest, UnifiedSearchResponse, NaturalSearchResponse } from '../../models/api/search.models';
+import * as i0 from "@angular/core";
+export interface SearchResult {
+    id: number;
+    entityType: string;
+    title?: string;
+    description?: string;
+    highlight?: string;
+    score?: number;
+}
+export interface SearchResponse {
+    hits: SearchResult[];
+    total: number;
+    query: string;
+    type?: string;
+    semanticSearchAvailable?: boolean;
+}
+export declare class SearchService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    /** Full-text search on a specific entity type */
+    search(q: string, type: string, limit?: number, offset?: number): Observable<ApiResponse<SearchResponse>>;
+    /** Full-text search across all entity types */
+    searchAll(q: string, limitPerEntity?: number): Observable<ApiResponse<SearchResponse>>;
+    /** Auto-suggest for a specific entity type */
+    suggest(q: string, type: string, limit?: number): Observable<ApiResponse<any>>;
+    /** Count search results */
+    count(q: string, type: string): Observable<ApiResponse<any>>;
+    /** Semantic search using AI embeddings */
+    semanticSearch(q: string, options?: {
+        type?: string;
+        limit?: number;
+        minSimilarity?: number;
+    }): Observable<ApiResponse<SearchResponse>>;
+    /** Hybrid search combining semantic + full-text */
+    hybridSearch(q: string, options?: {
+        type?: string;
+        limit?: number;
+    }): Observable<ApiResponse<SearchResponse>>;
+    /** Trigger full reindex of semantic search embeddings */
+    reindex(): Observable<ApiResponse<string>>;
+    /** Get semantic search index statistics */
+    stats(): Observable<ApiResponse<any>>;
+    /** Unified natural-language search — POST /api/search */
+    unifiedSearch(request: SearchRequest): Observable<ApiResponse<UnifiedSearchResponse>>;
+    /** Parse a natural-language query without executing — POST /api/search/natural */
+    parseQuery(request: SearchRequest): Observable<ApiResponse<NaturalSearchResponse>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchService>;
+}

package/lib/services/api/sensor.service.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { Sensor, SensorAlert } from '../../models/api/sensor.models';
+import { ApiResponse } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare class SensorService extends BaseCrudService<Sensor> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    pollAlerts(since: string, limit?: number): Observable<ApiResponse<SensorAlert[]>>;
+    /** Create a maintenance suppression window — all alerts suppressed during this period */
+    createMaintenanceWindow(sensorId: number, from: string, until: string, reason?: string): Observable<ApiResponse<any>>;
+    /** Get protocol adapters status */
+    getProtocols(): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SensorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SensorService>;
+}

package/lib/services/api/sla-policy.service.d.ts

@@ -0,0 +1,10 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ServiceLevelAgreement } from '../../models/api/maintenance.models';
+import * as i0 from "@angular/core";
+export declare class SlaPolicyService extends BaseCrudService<ServiceLevelAgreement> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlaPolicyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SlaPolicyService>;
+}

package/lib/services/api/sla.service.d.ts

@@ -0,0 +1,10 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { SlaBreachRecord } from '../../models/api/fleet.models';
+import * as i0 from "@angular/core";
+export declare class SlaBreachRecordService extends BaseCrudService<SlaBreachRecord> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlaBreachRecordService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SlaBreachRecordService>;
+}

package/lib/services/api/threshold-alert-rule.service.d.ts

@@ -0,0 +1,10 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ThresholdAlertRule } from '../../models/api/misc.models';
+import * as i0 from "@angular/core";
+export declare class ThresholdAlertRuleService extends BaseCrudService<ThresholdAlertRule> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThresholdAlertRuleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThresholdAlertRuleService>;
+}

package/lib/services/api/ticket.service.d.ts

@@ -0,0 +1,60 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { TicketRequest, TicketResponse, TicketCommentResponse, TicketAttachmentResponse } from '../../models/admin/ticket.models';
+import * as i0 from "@angular/core";
+/**
+ * Client-facing ticket service for regular users.
+ *
+ * Endpoint: `/api/tickets`
+ *
+ * Unlike the admin service (`/api/platform/tickets`), this is scoped
+ * to the current client and only exposes create, read, and comment operations.
+ * Update and delete are allowed while the ticket status is OPEN.
+ */
+export declare class TicketService {
+    private http;
+    private readonly basePath;
+    constructor(http: TgmHttpClient);
+    getAll(params?: {
+        status?: string;
+        page?: number;
+        size?: number;
+        sortBy?: string;
+        sortDir?: 'asc' | 'desc';
+    }): Observable<{
+        data: TicketResponse[];
+        total: number;
+        page: number;
+        totalPages: number;
+    }>;
+    getById(id: number): Observable<ApiResponse<TicketResponse>>;
+    create(data: TicketRequest): Observable<ApiResponse<TicketResponse>>;
+    /**
+     * Update an OPEN ticket. Returns 409 if the ticket is no longer OPEN.
+     */
+    update(id: number, data: Partial<TicketRequest>): Observable<ApiResponse<TicketResponse>>;
+    /**
+     * Delete (soft-delete) an OPEN ticket. Returns 409 if the ticket is no longer OPEN.
+     */
+    delete(id: number): Observable<ApiResponse<void>>;
+    getComments(id: number): Observable<{
+        data: TicketCommentResponse[];
+        total: number;
+    }>;
+    addComment(id: number, content: string): Observable<ApiResponse<TicketCommentResponse>>;
+    /**
+     * Upload an attachment to a ticket.
+     */
+    uploadAttachment(ticketId: number, file: File): Observable<ApiResponse<TicketAttachmentResponse>>;
+    /**
+     * List attachments for a ticket.
+     */
+    getAttachments(ticketId: number): Observable<ApiResponse<TicketAttachmentResponse[]>>;
+    /**
+     * Delete an attachment from a ticket.
+     */
+    deleteAttachment(ticketId: number, attachmentId: number): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TicketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TicketService>;
+}

package/lib/services/api/time-entry.service.d.ts

@@ -0,0 +1,10 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { TimeEntry } from '../../models/api/maintenance.models';
+import * as i0 from "@angular/core";
+export declare class TimeEntryService extends BaseCrudService<TimeEntry> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeEntryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimeEntryService>;
+}

package/lib/services/api/todo.service.d.ts

@@ -0,0 +1,10 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { Todo } from '../../models/api/misc.models';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+export declare class TodoService extends BaseCrudService<Todo> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TodoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TodoService>;
+}

package/lib/services/api/unit.service.d.ts

@@ -0,0 +1,10 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { Unit } from '../../models/api/unit.models';
+import * as i0 from "@angular/core";
+export declare class UnitService extends BaseCrudService<Unit> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UnitService>;
+}

package/lib/services/api/upload.service.d.ts

@@ -0,0 +1,50 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, PagedResponse, PaginationParams } from '../../models/base.models';
+import { StrapiFile } from '../../models/api/media.models';
+import * as i0 from "@angular/core";
+/** Options for uploading with ref/refId linking */
+export interface UploadWithRefOptions {
+    /** Entity type reference (e.g. 'api::note.note', 'api::form.form') */
+    ref: string;
+    /** Entity ID to link the file to */
+    refId: number;
+    /** Field name on the entity (e.g. 'attachments', 'cover') */
+    field: string;
+    /** Optional source identifier */
+    source?: string;
+}
+export declare class UploadService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    upload(file: File): Observable<ApiResponse<StrapiFile[]>>;
+    uploadMultiple(files: File[]): Observable<ApiResponse<StrapiFile[]>>;
+    /**
+     * Upload a file and link it to an entity via ref/refId/field.
+     * Use this when you need to attach uploads to specific entities (forms, messages, rooms, etc.).
+     */
+    uploadWithRef(file: File, options: UploadWithRefOptions): Observable<ApiResponse<StrapiFile[]>>;
+    linkFile(data: any): Observable<ApiResponse<StrapiFile>>;
+    linkExisting(fileId: number, data: any): Observable<ApiResponse<StrapiFile>>;
+    unlinkFile(fileId: number): Observable<ApiResponse<void>>;
+    download(fileId: number): Observable<Blob>;
+    getFileUrl(fileId: number): Observable<ApiResponse<{
+        url: string;
+    }>>;
+    deleteFile(fileId: number): Observable<ApiResponse<void>>;
+    /**
+     * List uploaded files with pagination.
+     */
+    list(params?: PaginationParams & Record<string, any>): Observable<PagedResponse<StrapiFile>>;
+    batchLink(data: any): Observable<ApiResponse<StrapiFile[]>>;
+    uploadAndLinkToNote(file: File, noteId: number): Observable<ApiResponse<StrapiFile[]>>;
+    uploadForCompany(companyId: number, file: File): Observable<ApiResponse<StrapiFile[]>>;
+    /**
+     * Upload files using a pre-built FormData object.
+     * Use this when you need to include extra metadata (ref, refId, field, source, path).
+     */
+    uploadFormData(formData: FormData): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UploadService>;
+}

package/lib/services/api/user.service.d.ts

@@ -0,0 +1,59 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { User, UserCreateRequest, UserUpdateRequest, UserNotification, Role, Profile, ProfilePermission } from '../../models/api/user.models';
+import * as i0 from "@angular/core";
+export declare class UserService extends BaseCrudService<User, UserCreateRequest, UserUpdateRequest> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    assignLocations(userId: number, locationIds: number[]): Observable<any>;
+    addLocation(userId: number, locationId: number): Observable<any>;
+    removeLocation(userId: number, locationId: number): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
+}
+export declare class UserProfileService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getMyProfile(): Observable<ApiResponse<User>>;
+    updateMyProfile(data: Partial<User>): Observable<ApiResponse<User>>;
+    changeMyPassword(data: {
+        currentPassword: string;
+        newPassword: string;
+        confirmPassword: string;
+    }): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserProfileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserProfileService>;
+}
+export declare class UserNotificationService extends BaseCrudService<UserNotification> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    markAllRead(): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserNotificationService>;
+}
+export declare class RoleService extends BaseCrudService<Role> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RoleService>;
+}
+export declare class ProfileService extends BaseCrudService<Profile> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProfileService>;
+}
+export declare class ProfilePermissionService extends BaseCrudService<ProfilePermission> {
+    private httpClient;
+    protected resourcePath: string;
+    constructor(httpClient: TgmHttpClient);
+    /**
+     * Get all permissions for a specific profile.
+     */
+    getByProfileId(profileId: number): Observable<ApiResponse<ProfilePermission[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProfilePermissionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProfilePermissionService>;
+}

package/lib/services/api/warehouse.service.d.ts

@@ -0,0 +1,15 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+export declare class WarehouseService extends BaseCrudService<any> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WarehouseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WarehouseService>;
+}
+export declare class WarehouseStockService extends BaseCrudService<any> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WarehouseStockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WarehouseStockService>;
+}

package/lib/services/api/warranty.service.d.ts

@@ -0,0 +1,16 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { WarrantyContract, WarrantyClaim } from '../../models/api/warranty.models';
+import * as i0 from "@angular/core";
+export declare class WarrantyContractService extends BaseCrudService<WarrantyContract> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WarrantyContractService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WarrantyContractService>;
+}
+export declare class WarrantyClaimService extends BaseCrudService<WarrantyClaim> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WarrantyClaimService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WarrantyClaimService>;
+}

package/lib/services/api/work-order.service.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+/**
+ * WorkOrderService — alias for MaintenanceRecordService.
+ * Work Orders were migrated to Maintenance Records in the backend.
+ * This service provides backward compatibility + custom query methods.
+ */
+export declare class WorkOrderService extends BaseCrudService<any> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getByUnit(unitId: number | string): Observable<any>;
+    getByStatus(status: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkOrderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkOrderService>;
+}

package/lib/services/api/work-permit.service.d.ts

@@ -0,0 +1,10 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { WorkPermit } from '../../models/api/work-permit.models';
+import * as i0 from "@angular/core";
+export declare class WorkPermitService extends BaseCrudService<WorkPermit> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<WorkPermitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WorkPermitService>;
+}

package/lib/services/api/workflow.service.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { ApprovalWorkflow, ApprovalStep, EscalationRule } from '../../models/api/workflow.models';
+import * as i0 from "@angular/core";
+export declare class ApprovalWorkflowService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    create(data: Partial<ApprovalWorkflow>): Observable<ApiResponse<ApprovalWorkflow>>;
+    getById(id: number): Observable<ApiResponse<ApprovalWorkflow>>;
+    getSteps(id: number): Observable<ApiResponse<ApprovalStep[]>>;
+    approve(id: number): Observable<ApiResponse<ApprovalWorkflow>>;
+    reject(id: number): Observable<ApiResponse<ApprovalWorkflow>>;
+    requestInfo(id: number): Observable<ApiResponse<ApprovalWorkflow>>;
+    delegate(id: number, body: any): Observable<ApiResponse<ApprovalWorkflow>>;
+    escalate(id: number): Observable<ApiResponse<ApprovalWorkflow>>;
+    cancel(id: number): Observable<ApiResponse<ApprovalWorkflow>>;
+    getMyPending(): Observable<ApiResponse<ApprovalWorkflow[]>>;
+    getMyRequests(): Observable<ApiResponse<ApprovalWorkflow[]>>;
+    getByStatus(status: string): Observable<ApiResponse<ApprovalWorkflow[]>>;
+    getByType(type: string): Observable<ApiResponse<ApprovalWorkflow[]>>;
+    getByEntity(entityType: string, entityId: number): Observable<ApiResponse<ApprovalWorkflow[]>>;
+    getEscalated(): Observable<ApiResponse<ApprovalWorkflow[]>>;
+    getOverdue(): Observable<ApiResponse<ApprovalWorkflow[]>>;
+    getDashboard(): Observable<ApiResponse<any>>;
+    getEscalationRules(): Observable<ApiResponse<EscalationRule[]>>;
+    createEscalationRule(data: Partial<EscalationRule>): Observable<ApiResponse<EscalationRule>>;
+    updateEscalationRule(id: number, data: Partial<EscalationRule>): Observable<ApiResponse<EscalationRule>>;
+    deleteEscalationRule(id: number): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApprovalWorkflowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApprovalWorkflowService>;
+}

package/lib/services/auth/auth.service.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { LoginRequest, BadgePinLoginRequest, RegisterRequest, ForgotPasswordRequest, ResetPasswordRequest, AuthResponse, UserDto } from '../../models/auth/login.models';
+import * as i0 from "@angular/core";
+export declare class AuthService {
+    private http;
+    private currentUser$;
+    private authenticated$;
+    readonly user$: Observable<UserDto>;
+    readonly isAuthenticated$: Observable<boolean>;
+    constructor(http: TgmHttpClient);
+    login(credentials: LoginRequest): Observable<AuthResponse>;
+    badgeLogin(credentials: BadgePinLoginRequest): Observable<AuthResponse>;
+    register(data: RegisterRequest): Observable<AuthResponse>;
+    forgotPassword(data: ForgotPasswordRequest): Observable<any>;
+    resetPassword(data: ResetPasswordRequest): Observable<any>;
+    refreshToken(): Observable<AuthResponse>;
+    getCurrentUser(): Observable<AuthResponse>;
+    logout(): void;
+    getToken(): string | null;
+    isAuthenticated(): boolean;
+    getUser(): UserDto | null;
+    getAnnouncements(): Observable<any[]>;
+    getSandboxes(): Observable<any[]>;
+    getSandboxesByEmail(email: string): Observable<any[]>;
+    sendVerificationEmail(): Observable<any>;
+    verifyEmail(token: string): Observable<any>;
+    validateInviteToken(token: string): Observable<any>;
+    acceptInvite(data: any): Observable<AuthResponse>;
+    private handleAuthResponse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/lib/services/auth/index.d.ts

@@ -0,0 +1,4 @@
+export { AuthService } from './auth.service';
+export { SsoAuthService } from './sso-auth.service';
+export { TotpService } from './totp.service';
+export { PlatformAuthService } from './platform-auth.service';

package/lib/services/auth/platform-auth.service.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { PlatformLoginRequest, PlatformAuthResponse, PlatformAdminResponse } from '../../models/admin/platform-admin.models';
+import * as i0 from "@angular/core";
+export declare class PlatformAuthService {
+    private http;
+    private currentAdmin$;
+    readonly admin$: Observable<PlatformAdminResponse>;
+    constructor(http: TgmHttpClient);
+    login(credentials: PlatformLoginRequest): Observable<PlatformAuthResponse>;
+    getCurrentAdmin(): Observable<PlatformAdminResponse>;
+    logout(): void;
+    getAdmin(): PlatformAdminResponse | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformAuthService>;
+}

package/lib/services/auth/sso-auth.service.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { SsoLoginRequest, SsoCallbackRequest, SamlCallbackRequest, LinkAccountRequest, SsoAuthorizationResponse, SsoProviderListResponse, LinkedAccountResponse } from '../../models/auth/sso.models';
+import { AuthResponse } from '../../models/auth/login.models';
+import { ApiResponse } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare class SsoAuthService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getProviders(): Observable<SsoProviderListResponse>;
+    authorize(request: SsoLoginRequest): Observable<SsoAuthorizationResponse>;
+    handleCallback(providerId: number, params: SsoCallbackRequest): Observable<AuthResponse>;
+    handleSamlCallback(data: SamlCallbackRequest): Observable<AuthResponse>;
+    getSamlMetadata(): Observable<string>;
+    linkAccount(request: LinkAccountRequest): Observable<ApiResponse<any>>;
+    unlinkAccount(providerId: number): Observable<ApiResponse<any>>;
+    getLinkedAccounts(): Observable<LinkedAccountResponse[]>;
+    setPrimaryProvider(providerId: number): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SsoAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SsoAuthService>;
+}

package/lib/services/auth/totp.service.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { TotpSetupRequest, TotpVerifyRequest, TotpSetupResponse, TotpStatusResponse } from '../../models/auth/totp.models';
+import { AuthResponse } from '../../models/auth/login.models';
+import { ApiResponse } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare class TotpService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getStatus(): Observable<TotpStatusResponse>;
+    setup(): Observable<TotpSetupResponse>;
+    verifySetup(data: TotpSetupRequest): Observable<ApiResponse<any>>;
+    disable(data: TotpSetupRequest): Observable<ApiResponse<any>>;
+    verify(data: TotpVerifyRequest): Observable<AuthResponse>;
+    regenerateRecoveryCodes(): Observable<ApiResponse<string[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TotpService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TotpService>;
+}

package/lib/services/chat/chat-rest.service.d.ts

@@ -0,0 +1,40 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, PagedResponse, PaginationParams } from '../../models/base.models';
+import { Conversation, ChatMessage, ChatParticipant, PresenceResponse, CreateConversationRequest, SendMessageRequest, UpdateConversationRequest, AddParticipantRequest, EditMessageRequest } from '../../models/chat/chat.models';
+import * as i0 from "@angular/core";
+export declare class ChatRestService {
+    private http;
+    private readonly basePath;
+    constructor(http: TgmHttpClient);
+    getConversations(params?: PaginationParams & {
+        search?: string;
+    }): Observable<PagedResponse<Conversation>>;
+    getConversation(id: number): Observable<ApiResponse<Conversation>>;
+    createConversation(data: CreateConversationRequest): Observable<ApiResponse<Conversation>>;
+    updateConversation(id: number, data: UpdateConversationRequest): Observable<ApiResponse<Conversation>>;
+    deleteConversation(id: number): Observable<ApiResponse<void>>;
+    archiveConversation(id: number): Observable<ApiResponse<void>>;
+    unarchiveConversation(id: number): Observable<ApiResponse<void>>;
+    muteConversation(id: number): Observable<ApiResponse<void>>;
+    unmuteConversation(id: number): Observable<ApiResponse<void>>;
+    pinConversation(id: number): Observable<ApiResponse<void>>;
+    unpinConversation(id: number): Observable<ApiResponse<void>>;
+    getMessages(conversationId: number, params?: PaginationParams): Observable<PagedResponse<ChatMessage>>;
+    sendMessage(data: SendMessageRequest): Observable<ApiResponse<ChatMessage>>;
+    editMessage(messageId: number, data: EditMessageRequest): Observable<ApiResponse<ChatMessage>>;
+    deleteMessage(messageId: number): Observable<ApiResponse<void>>;
+    getReplies(messageId: number, params?: PaginationParams): Observable<PagedResponse<ChatMessage>>;
+    searchMessages(conversationId: number, query: string): Observable<ChatMessage[]>;
+    getParticipants(conversationId: number): Observable<ChatParticipant[]>;
+    addParticipants(conversationId: number, data: AddParticipantRequest): Observable<ApiResponse<void>>;
+    removeParticipant(conversationId: number, userId: number): Observable<ApiResponse<void>>;
+    leaveConversation(conversationId: number): Observable<ApiResponse<void>>;
+    addReaction(messageId: number, emoji: string): Observable<ApiResponse<void>>;
+    removeReaction(messageId: number, emoji: string): Observable<ApiResponse<void>>;
+    markAsRead(conversationId: number, lastMessageId?: number): Observable<ApiResponse<void>>;
+    getPresence(): Observable<PresenceResponse[]>;
+    getUserPresence(userId: number): Observable<PresenceResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatRestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatRestService>;
+}

package/lib/services/chat/chat-websocket.service.d.ts

@@ -0,0 +1,34 @@
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { WebSocketService } from '../../core/websocket.service';
+import { ChatMessage, TypingIndicatorResponse, PresenceResponse, ReadReceiptBroadcast, ReactionBroadcast, SendMessageRequest } from '../../models/chat/chat.models';
+import * as i0 from "@angular/core";
+export declare class ChatWebSocketService implements OnDestroy {
+    private ws;
+    private destroy$;
+    private connected;
+    /** Incoming new messages */
+    readonly messages$: Observable<ChatMessage>;
+    /** Typing indicators */
+    readonly typing$: Observable<TypingIndicatorResponse>;
+    /** Presence updates */
+    readonly presence$: Observable<PresenceResponse>;
+    /** Read receipt broadcasts */
+    readonly readReceipts$: Observable<ReadReceiptBroadcast>;
+    /** Reaction broadcasts */
+    readonly reactions$: Observable<ReactionBroadcast>;
+    /** Error messages */
+    readonly errors$: Observable<any>;
+    constructor(ws: WebSocketService);
+    connect(): void;
+    disconnect(): void;
+    sendMessage(request: SendMessageRequest): void;
+    sendTyping(conversationId: number, typing: boolean): void;
+    markRead(conversationId: number, lastMessageId?: number): void;
+    sendReaction(messageId: number, conversationId: number, emoji: string, add: boolean): void;
+    updatePresence(online: boolean, deviceType?: string): void;
+    heartbeat(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChatWebSocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ChatWebSocketService>;
+}

package/lib/services/chat/index.d.ts

@@ -0,0 +1,2 @@
+export { ChatRestService } from './chat-rest.service';
+export { ChatWebSocketService } from './chat-websocket.service';