@en-solutions/tgm-client-sdk 1.6.21

package/lib/models/enums/user.enums.d.ts

@@ -0,0 +1,31 @@
+export declare const AppLanguage: {
+    readonly EN: "EN";
+    readonly FR: "FR";
+    readonly PT: "PT";
+    readonly DE: "DE";
+    readonly ES: "ES";
+};
+export type AppLanguage = (typeof AppLanguage)[keyof typeof AppLanguage];
+export declare const PlatformAdminRole: {
+    readonly SUPER_ADMIN: "SUPER_ADMIN";
+};
+export type PlatformAdminRole = (typeof PlatformAdminRole)[keyof typeof PlatformAdminRole];
+export declare const ParticipantRole: {
+    readonly OWNER: "OWNER";
+    readonly ADMIN: "ADMIN";
+    readonly MEMBER: "MEMBER";
+};
+export type ParticipantRole = (typeof ParticipantRole)[keyof typeof ParticipantRole];
+export declare const RoleType: {
+    readonly SUPER_ADMIN: "SUPER_ADMIN";
+    readonly ADMIN: "ADMIN";
+    readonly MANAGER: "MANAGER";
+    readonly USER: "USER";
+};
+export type RoleType = (typeof RoleType)[keyof typeof RoleType];
+export declare const SandboxAccessLevel: {
+    readonly OWNER: "OWNER";
+    readonly ADMIN: "ADMIN";
+    readonly USER: "USER";
+};
+export type SandboxAccessLevel = (typeof SandboxAccessLevel)[keyof typeof SandboxAccessLevel];

package/lib/models/enums/work-permit.enums.d.ts

@@ -0,0 +1,56 @@
+export declare const WorkPermitCategory: {
+    readonly PC1: "PC1";
+    readonly PC2: "PC2";
+    readonly PC2B: "PC2B";
+    readonly PC11: "PC11";
+    readonly PC14: "PC14";
+    readonly PC17: "PC17";
+};
+export type WorkPermitCategory = (typeof WorkPermitCategory)[keyof typeof WorkPermitCategory];
+export declare const WorkPermitStatus: {
+    readonly DRAFT: "DRAFT";
+    readonly ISSUED: "ISSUED";
+    readonly APPROVED: "APPROVED";
+    readonly REJECTED: "REJECTED";
+    readonly ACTIVE: "ACTIVE";
+    readonly SURRENDERED: "SURRENDERED";
+    readonly EXPIRED: "EXPIRED";
+    readonly COMPLETED: "COMPLETED";
+    readonly CANCELLED: "CANCELLED";
+};
+export type WorkPermitStatus = (typeof WorkPermitStatus)[keyof typeof WorkPermitStatus];
+export declare const PC2PermitSubType: {
+    readonly WORK_PERMIT: "WORK_PERMIT";
+    readonly WORK_AND_TEST_PERMIT: "WORK_AND_TEST_PERMIT";
+    readonly STATION_GUARANTEE: "STATION_GUARANTEE";
+};
+export type PC2PermitSubType = (typeof PC2PermitSubType)[keyof typeof PC2PermitSubType];
+export declare const WorkOrderSourceType: {
+    readonly INTERVENTION: "INTERVENTION";
+    readonly INSPECTION: "INSPECTION";
+    readonly WORK_ORDER_REQUEST: "WORK_ORDER_REQUEST";
+};
+export type WorkOrderSourceType = (typeof WorkOrderSourceType)[keyof typeof WorkOrderSourceType];
+export declare const PermitOrigin: {
+    readonly INTERNAL: "INTERNAL";
+    readonly EXTERNAL: "EXTERNAL";
+};
+export type PermitOrigin = (typeof PermitOrigin)[keyof typeof PermitOrigin];
+export declare const ActivePermitHolder: {
+    readonly PRIMARY: "PRIMARY";
+    readonly ALTERNATE: "ALTERNATE";
+};
+export type ActivePermitHolder = (typeof ActivePermitHolder)[keyof typeof ActivePermitHolder];
+export declare const EnergySourceType: {
+    readonly ELECTRICAL_HV: "ELECTRICAL_HV";
+    readonly ELECTRICAL_LV: "ELECTRICAL_LV";
+    readonly HYDRAULIC: "HYDRAULIC";
+    readonly MECHANICAL: "MECHANICAL";
+    readonly PNEUMATIC: "PNEUMATIC";
+    readonly THERMAL: "THERMAL";
+    readonly GRAVITY: "GRAVITY";
+    readonly CHEMICAL: "CHEMICAL";
+    readonly PRESSURE: "PRESSURE";
+    readonly STORED_ENERGY: "STORED_ENERGY";
+};
+export type EnergySourceType = (typeof EnergySourceType)[keyof typeof EnergySourceType];

package/lib/models/index.d.ts

@@ -0,0 +1,41 @@
+export * from './base.models';
+export * from './enums';
+export * from './auth';
+export * from './admin';
+export * from './api/company.models';
+export * from './api/unit.models';
+export * from './api/component.models';
+export * from './api/inspection.models';
+export * from './api/failure.models';
+export * from './api/intervention.models';
+export * from './api/maintenance-record.models';
+export * from './api/material.models';
+export * from './api/sensor.models';
+export * from './api/project.models';
+export * from './api/document.models';
+export * from './api/compliance.models';
+export * from './api/energy.models';
+export * from './api/warranty.models';
+export * from './api/fleet.models';
+export * from './api/knowledge.models';
+export * from './api/quality.models';
+export * from './api/workflow.models';
+export * from './api/custom-field.models';
+export * from './api/user.models';
+export * from './api/misc.models';
+export * from './api/reservoir.models';
+export * from './chat/chat.models';
+export * from './api/media.models';
+export * from './api/cat.models';
+export * from './api/maintenance.models';
+export * from './video/video-call.models';
+export * from './realtime/realtime-event.models';
+export * from './api/work-permit.models';
+export * from './api/loto.models';
+export * from './api/diagnostic-report.models';
+export * from './api/cortex-node.models';
+export * from './api/cortex-edge.models';
+export * from './api/cortex-event.models';
+export * from './api/cortex-insight.models';
+export * from './api/aip.models';
+export * from './api/reservoir-websocket.models';

package/lib/models/realtime/realtime-event.models.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Real-time event models for entity CRUD changes and dynamic queue messages.
+ *
+ * Entity changes are broadcast when any entity is created, updated, or deleted
+ * via the API. Dynamic queue messages are broadcast when a RabbitMQ queue message
+ * is successfully processed by a handler.
+ */
+export type EntityAction = 'created' | 'updated' | 'deleted';
+/**
+ * Event broadcast when an entity is created, updated, or deleted.
+ *
+ * Subscribe to:
+ *   /topic/entities                 — all entity changes (firehose)
+ *   /topic/entities/{resourceName}  — changes for a specific resource
+ *
+ * @template T The entity type (defaults to any)
+ */
+export interface EntityChangeEvent<T = any> {
+    /** API resource name (plural) — e.g. 'inspections', 'units', 'interventions' */
+    resourceName: string;
+    /** The CRUD action that triggered this event */
+    action: EntityAction;
+    /** The entity ID */
+    entityId: number;
+    /** ISO timestamp of when the event was broadcast */
+    timestamp: string;
+    /** Full entity object on create/update. null on delete. */
+    data: T | null;
+}
+/** Handler types for dynamic queue message processing */
+export type QueueHandlerType = 'generic' | 'iot' | 'notification' | 'erp' | 'webhook' | string;
+/**
+ * Event broadcast when a dynamic queue message is successfully processed.
+ *
+ * Subscribe to:
+ *   /topic/queues                — all queue messages (firehose)
+ *   /topic/queues/{queueName}   — messages from a specific queue
+ *
+ * @template T The payload type (defaults to any)
+ */
+export interface QueueMessageEvent<T = any> {
+    /** The RabbitMQ queue name — e.g. 'tgm_iot', 'my_alerts_queue' */
+    queueName: string;
+    /** Handler that processed the message — e.g. 'generic', 'iot', 'notification' */
+    handlerType: QueueHandlerType;
+    /** The RabbitMQ routing key the message was published with */
+    routingKey: string;
+    /** ISO timestamp of when the message was broadcast */
+    timestamp: string;
+    /** The original message payload from RabbitMQ */
+    payload: T | null;
+}
+/**
+ * Wrapper for the firehose /topic/queues destination.
+ * Contains the queue name and the full message event.
+ */
+export interface QueueMessageFirehoseEvent<T = any> {
+    queueName: string;
+    data: QueueMessageEvent<T>;
+}
+/**
+ * IoT sensor event broadcast on /topic/iot-event.
+ */
+export interface IoTEvent {
+    type: 'iot';
+    sensorId?: number;
+    unitId?: number;
+    value?: number;
+    alertLevel?: 'normal' | 'warning' | 'critical';
+    timestamp?: string;
+    clientId?: string;
+    sandbox?: string;
+    [key: string]: any;
+}
+/**
+ * User notification delivered on /user/queue/notifications.
+ */
+export interface NotificationEvent {
+    type: 'notification';
+    userId?: number;
+    title?: string;
+    message?: string;
+    link?: string;
+    priority?: string;
+    [key: string]: any;
+}
+/**
+ * Calendar update delivered on /user/queue/calendar.
+ */
+export interface CalendarUpdateEvent {
+    action: string;
+    entityType: string;
+    entityId: number;
+    timestamp: string;
+}

package/lib/models/video/video-call.models.d.ts

@@ -0,0 +1,65 @@
+import { VideoCallType, VideoCallStatus, VideoParticipantRole, VideoParticipantStatus } from '../enums';
+export interface VideoCall {
+    id: number;
+    type: VideoCallType;
+    status: VideoCallStatus;
+    initiatorId: number;
+    initiatorName?: string;
+    conversationId?: number;
+    livekitRoomName?: string;
+    startedAt?: string;
+    endedAt?: string;
+    durationSeconds?: number;
+    hasVideo?: boolean;
+    hasScreenShare?: boolean;
+    isRecorded?: boolean;
+    participants?: VideoCallParticipant[];
+    createdAt?: string;
+}
+export interface VideoCallParticipant {
+    id: number;
+    userId: number;
+    username?: string;
+    displayName?: string;
+    role?: VideoParticipantRole;
+    status?: VideoParticipantStatus;
+    audioEnabled?: boolean;
+    videoEnabled?: boolean;
+    screenShareEnabled?: boolean;
+    joinedAt?: string;
+    leftAt?: string;
+    durationSeconds?: number;
+}
+export interface InitiateCallRequest {
+    companyId: number;
+    targetUserIds: number[];
+    conversationId?: number;
+    hasVideo?: boolean;
+    type?: string;
+}
+export interface AnswerCallRequest {
+    callId: number;
+    accepted: boolean;
+}
+export interface VideoCallTokenResponse {
+    token: string;
+    wsUrl: string;
+    roomName: string;
+}
+export interface IncomingCallEvent {
+    callId: number;
+    type: VideoCallType;
+    hasVideo: boolean;
+    initiatorId: number;
+    initiatorName: string;
+    roomName?: string;
+}
+export interface CallAnsweredEvent {
+    callId: number;
+    userId: number;
+    accepted: boolean;
+}
+export interface CallEndedEvent {
+    callId: number;
+    endedBy: number;
+}

package/lib/services/admin/activity-log.service.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import * as i0 from "@angular/core";
+export declare class ActivityLogService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<any[]>;
+    getRecent(): Observable<any[]>;
+    getClientLogs(): Observable<any[]>;
+    getEligibleClients(): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityLogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActivityLogService>;
+}

package/lib/services/admin/announcement.service.d.ts

@@ -0,0 +1,17 @@
+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 AnnouncementService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<any[]>;
+    getActive(): Observable<any[]>;
+    getBanners(): Observable<any[]>;
+    getById(id: number): Observable<ApiResponse<any>>;
+    create(data: any): Observable<ApiResponse<any>>;
+    update(id: number, data: any): Observable<ApiResponse<any>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnnouncementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnnouncementService>;
+}

package/lib/services/admin/article-admin.service.d.ts

@@ -0,0 +1,17 @@
+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 ArticleAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<any[]>;
+    getPublished(): Observable<any[]>;
+    getFeatured(): Observable<any[]>;
+    getById(id: number): Observable<ApiResponse<any>>;
+    create(data: any): Observable<ApiResponse<any>>;
+    update(id: number, data: any): Observable<ApiResponse<any>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArticleAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArticleAdminService>;
+}

package/lib/services/admin/audit-log.service.d.ts

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { PaginationParams } from '../../models/base.models';
+import { AuditLogResponse, AuditLogStatsResponse } from '../../models/admin/audit.models';
+import * as i0 from "@angular/core";
+export declare class AuditLogService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getInfluxDbStatus(): Observable<any>;
+    getInfluxDbLogs(startTime: string, endTime: string): Observable<AuditLogResponse[]>;
+    getSecurityEvents(): Observable<AuditLogResponse[]>;
+    getActionStats(): Observable<AuditLogStatsResponse>;
+    getEntityStats(): Observable<AuditLogStatsResponse>;
+    getUserAuditLogs(userId: number): Observable<AuditLogResponse[]>;
+    getPlatformLogs(params?: PaginationParams): Observable<any>;
+    getRecentPlatformLogs(): Observable<any[]>;
+    getEntityAuditTrail(entityType: string, entityId: number): Observable<any[]>;
+    getClientLogs(): Observable<any[]>;
+    getEligibleClients(): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuditLogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuditLogService>;
+}

package/lib/services/admin/backup.service.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { BackupResponse } from '../../models/admin/backup.models';
+import * as i0 from "@angular/core";
+export declare class BackupService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<BackupResponse[]>;
+    getByClient(clientId: number): Observable<BackupResponse[]>;
+    create(clientId: number): Observable<ApiResponse<BackupResponse>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BackupService>;
+}

package/lib/services/admin/cache-admin.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 CacheAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getStatistics(): Observable<any>;
+    evictAll(): Observable<ApiResponse<any>>;
+    evictReferenceData(): Observable<ApiResponse<any>>;
+    evictDashboard(): Observable<ApiResponse<any>>;
+    evictUser(userId: number): Observable<ApiResponse<any>>;
+    evictCompany(companyId: number): Observable<ApiResponse<any>>;
+    evictErp(): Observable<ApiResponse<any>>;
+    evictErpConnection(connectionId: number): Observable<ApiResponse<any>>;
+    evictAlerts(): Observable<ApiResponse<any>>;
+    evictInventory(): Observable<ApiResponse<any>>;
+    deleteSession(userId: number): Observable<ApiResponse<void>>;
+    getSessions(userId: number): Observable<any>;
+    getLockStatus(lockName: string): Observable<any>;
+    releaseLock(lockName: string): Observable<ApiResponse<void>>;
+    getCounter(name: string): Observable<any>;
+    resetCounter(name: string): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CacheAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CacheAdminService>;
+}

package/lib/services/admin/client-admin.service.d.ts

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, PagedResponse, PaginationParams } from '../../models/base.models';
+import { ClientResponse, ClientCreateRequest, ClientUpdateRequest, ClientAnalyticsResponse, LicenseResponse, LicenseOverviewItem, MigrationStatusResponse, MigrationHistoryResponse } from '../../models/admin/client.models';
+import * as i0 from "@angular/core";
+export declare class ClientAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(params?: PaginationParams): Observable<PagedResponse<ClientResponse>>;
+    getActive(): Observable<ClientResponse[]>;
+    getById(id: number): Observable<ApiResponse<ClientResponse>>;
+    create(data: ClientCreateRequest): Observable<ApiResponse<ClientResponse>>;
+    update(id: number, data: ClientUpdateRequest): Observable<ApiResponse<ClientResponse>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    provision(id: number): Observable<ApiResponse<any>>;
+    provisionInfluxDb(id: number): Observable<ApiResponse<any>>;
+    suspend(id: number): Observable<ApiResponse<any>>;
+    activate(id: number): Observable<ApiResponse<any>>;
+    migrateAll(): Observable<ApiResponse<any>>;
+    migrateClient(id: number): Observable<ApiResponse<any>>;
+    getMigrationStatus(): Observable<MigrationStatusResponse>;
+    getMigrationHistory(): Observable<MigrationHistoryResponse[]>;
+    getMigrationBatch(batchId: string): Observable<any>;
+    getFailedMigrations(): Observable<MigrationHistoryResponse[]>;
+    getClientMigrationHistory(identifier: string): Observable<MigrationHistoryResponse[]>;
+    retryMigration(identifier: string): Observable<ApiResponse<any>>;
+    bulkMigrate(ids: number[]): Observable<ApiResponse<any>>;
+    bulkSuspend(ids: number[]): Observable<ApiResponse<any>>;
+    bulkActivate(ids: number[]): Observable<ApiResponse<any>>;
+    getLicense(id: number): Observable<LicenseResponse>;
+    generateLicense(id: number): Observable<ApiResponse<any>>;
+    installLicense(id: number, data: any): Observable<ApiResponse<any>>;
+    generateAndInstallLicense(id: number): Observable<ApiResponse<any>>;
+    getLicenseOverview(): Observable<LicenseOverviewItem[]>;
+    getAnalytics(): Observable<ClientAnalyticsResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientAdminService>;
+}

package/lib/services/admin/client-api-key.service.d.ts

@@ -0,0 +1,15 @@
+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 ClientApiKeyService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(clientId: number): Observable<any[]>;
+    create(clientId: number, data: any): Observable<ApiResponse<any>>;
+    updatePermissions(clientId: number, keyId: number, data: any): Observable<ApiResponse<any>>;
+    getEntityTypes(clientId: number): Observable<any[]>;
+    delete(clientId: number, keyId: number): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientApiKeyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientApiKeyService>;
+}

package/lib/services/admin/client-ocr.service.d.ts

@@ -0,0 +1,14 @@
+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 ClientOcrService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getStatus(clientId: number): Observable<any>;
+    toggle(clientId: number): Observable<ApiResponse<any>>;
+    start(clientId: number): Observable<ApiResponse<any>>;
+    retryFailed(clientId: number): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientOcrService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientOcrService>;
+}

package/lib/services/admin/client-usage.service.d.ts

@@ -0,0 +1,15 @@
+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 ClientUsageService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<any[]>;
+    getByClient(clientId: number): Observable<any>;
+    getHistory(clientId: number): Observable<any[]>;
+    collect(): Observable<ApiResponse<any>>;
+    getDbHealth(clientId: number): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientUsageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientUsageService>;
+}

package/lib/services/admin/data-export.service.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import * as i0 from "@angular/core";
+export declare class DataExportService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getSummary(clientId: number): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataExportService>;
+}

package/lib/services/admin/document-admin.service.d.ts

@@ -0,0 +1,18 @@
+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 DocumentAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getOcrStatus(): Observable<any>;
+    getStats(): Observable<any>;
+    getAll(): Observable<any[]>;
+    getById(fileId: number): Observable<ApiResponse<any>>;
+    reprocess(fileId: number): Observable<ApiResponse<any>>;
+    reprocessFailed(): Observable<ApiResponse<any>>;
+    process(fileId: number): Observable<ApiResponse<any>>;
+    delete(fileId: number): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentAdminService>;
+}

package/lib/services/admin/email-admin.service.d.ts

@@ -0,0 +1,14 @@
+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 EmailAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getStatus(): Observable<any>;
+    testConfig(): Observable<ApiResponse<any>>;
+    testTemplate(templateName: string): Observable<ApiResponse<any>>;
+    getTemplates(): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmailAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EmailAdminService>;
+}

package/lib/services/admin/email-provider.service.d.ts

@@ -0,0 +1,25 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { EmailProviderConfigRequest, EmailProviderConfigResponse } from '../../models/admin/email-provider.models';
+import * as i0 from "@angular/core";
+export declare class EmailProviderAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getTypes(): Observable<any[]>;
+    getSystem(): Observable<EmailProviderConfigResponse>;
+    getByCompany(companyId: number): Observable<EmailProviderConfigResponse[]>;
+    getById(id: number): Observable<ApiResponse<EmailProviderConfigResponse>>;
+    create(data: EmailProviderConfigRequest): Observable<ApiResponse<EmailProviderConfigResponse>>;
+    update(id: number, data: Partial<EmailProviderConfigRequest>): Observable<ApiResponse<EmailProviderConfigResponse>>;
+    activate(id: number): Observable<ApiResponse<any>>;
+    deactivate(id: number): Observable<ApiResponse<any>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    test(id: number): Observable<ApiResponse<any>>;
+    testEmail(id: number): Observable<ApiResponse<any>>;
+    quickSetupSendgrid(data: any): Observable<ApiResponse<EmailProviderConfigResponse>>;
+    quickSetupSmtp(data: any): Observable<ApiResponse<EmailProviderConfigResponse>>;
+    getStatus(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmailProviderAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EmailProviderAdminService>;
+}

package/lib/services/admin/erp-admin.service.d.ts

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { ErpConnectionRequest, ErpConnectionResponse, ErpEntityMappingRequest, ErpEntityMappingResponse, ErpSyncJobResponse, SyncScheduleConfigRequest, SyncScheduleConfigResponse, ErpDashboardResponse } from '../../models/admin/erp.models';
+import * as i0 from "@angular/core";
+export declare class ErpAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getConnections(): Observable<ErpConnectionResponse[]>;
+    getConnection(id: number): Observable<ApiResponse<ErpConnectionResponse>>;
+    createConnection(data: ErpConnectionRequest): Observable<ApiResponse<ErpConnectionResponse>>;
+    updateConnection(id: number, data: Partial<ErpConnectionRequest>): Observable<ApiResponse<ErpConnectionResponse>>;
+    deleteConnection(id: number): Observable<ApiResponse<void>>;
+    testConnection(id: number): Observable<ApiResponse<any>>;
+    enableConnection(id: number): Observable<ApiResponse<any>>;
+    disableConnection(id: number): Observable<ApiResponse<any>>;
+    getMappings(connectionId: number): Observable<ErpEntityMappingResponse[]>;
+    getMapping(id: number): Observable<ApiResponse<ErpEntityMappingResponse>>;
+    createMapping(connectionId: number, data: ErpEntityMappingRequest): Observable<ApiResponse<ErpEntityMappingResponse>>;
+    updateMapping(id: number, data: Partial<ErpEntityMappingRequest>): Observable<ApiResponse<ErpEntityMappingResponse>>;
+    deleteMapping(id: number): Observable<ApiResponse<void>>;
+    getSyncJobs(connectionId: number): Observable<ErpSyncJobResponse[]>;
+    getSyncJob(id: number): Observable<ApiResponse<ErpSyncJobResponse>>;
+    fullSync(connectionId: number): Observable<ApiResponse<ErpSyncJobResponse>>;
+    incrementalSync(connectionId: number): Observable<ApiResponse<ErpSyncJobResponse>>;
+    entitySync(connectionId: number, data: any): Observable<ApiResponse<ErpSyncJobResponse>>;
+    cancelSyncJob(id: number): Observable<ApiResponse<any>>;
+    getSyncStatistics(connectionId: number): Observable<any>;
+    getRunningJobs(): Observable<ErpSyncJobResponse[]>;
+    getSyncJobDetail(id: number): Observable<any>;
+    retrySyncJob(id: number): Observable<ApiResponse<ErpSyncJobResponse>>;
+    getSchedule(connectionId: number): Observable<SyncScheduleConfigResponse>;
+    updateSchedule(connectionId: number, data: SyncScheduleConfigRequest): Observable<ApiResponse<SyncScheduleConfigResponse>>;
+    enableSchedule(connectionId: number): Observable<ApiResponse<any>>;
+    disableSchedule(connectionId: number): Observable<ApiResponse<any>>;
+    getDashboard(): Observable<ErpDashboardResponse>;
+    getSupportedErpTypes(): Observable<any[]>;
+    getSyncableEntities(): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErpAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErpAdminService>;
+}

package/lib/services/admin/identity-provider.service.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { IdentityProviderRequest, IdentityProviderResponse } from '../../models/admin/identity-provider.models';
+import * as i0 from "@angular/core";
+export declare class IdentityProviderAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<IdentityProviderResponse[]>;
+    getById(id: number): Observable<ApiResponse<IdentityProviderResponse>>;
+    create(data: IdentityProviderRequest): Observable<ApiResponse<IdentityProviderResponse>>;
+    update(id: number, data: Partial<IdentityProviderRequest>): Observable<ApiResponse<IdentityProviderResponse>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    test(id: number): Observable<ApiResponse<any>>;
+    discover(data: any): Observable<ApiResponse<any>>;
+    autoConfigure(id: number): Observable<ApiResponse<any>>;
+    updateStatus(id: number, data: any): Observable<ApiResponse<any>>;
+    getPresets(): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdentityProviderAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdentityProviderAdminService>;
+}

package/lib/services/admin/impersonation.service.d.ts

@@ -0,0 +1,11 @@
+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 ImpersonationService {
+    private http;
+    constructor(http: TgmHttpClient);
+    impersonate(clientId: number): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImpersonationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ImpersonationService>;
+}