@en-solutions/tgm-client-sdk 1.6.21

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

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { SensorAlert } from '../../models/api/sensor.models';
+import { ApiResponse } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare class AlertService extends BaseCrudService<SensorAlert> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    acknowledge(id: number): Observable<ApiResponse<SensorAlert>>;
+    resolve(id: number): Observable<ApiResponse<SensorAlert>>;
+    escalate(id: number): Observable<ApiResponse<SensorAlert>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertService>;
+}

package/lib/services/api/anomaly-detection.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 { AnomalyDetection, AnomalyForecast } from '../../models/api/sensor.models';
+import * as i0 from "@angular/core";
+/**
+ * Client-facing anomaly detection service.
+ *
+ * - `getAnomalies()` uses `/api/alerts` (SensorAlert CRUD, client-scoped)
+ * - `getForecast()` uses `/api/alerts/forecast` (if backend exposes it)
+ *
+ * The internal Python service endpoints (`/api/internal/...`) require
+ * `hasRole('API')` and are NOT accessible from the frontend.
+ */
+export declare class AnomalyDetectionService {
+    private http;
+    constructor(http: TgmHttpClient);
+    /** List recent anomaly alerts (sensor alerts) with pagination + sorting */
+    getAnomalies(params?: Record<string, any>): Observable<any>;
+    /** Get a single alert by ID */
+    getAnomalyById(id: number): Observable<ApiResponse<AnomalyDetection>>;
+    /** Forecast endpoint — available when Cortex ML is enabled */
+    getForecast(sensorId: number, horizon?: string): Observable<ApiResponse<AnomalyForecast[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnomalyDetectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnomalyDetectionService>;
+}

package/lib/services/api/asset-lifecycle.service.d.ts

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, PagedResponse, PaginationParams } from '../../models/base.models';
+import { AssetLifecycle, LifecycleEvent } from '../../models/api/maintenance.models';
+import * as i0 from "@angular/core";
+export declare class AssetLifecycleService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getAll(params?: PaginationParams & Record<string, any>): Observable<PagedResponse<AssetLifecycle>>;
+    create(componentId: number, data: Partial<AssetLifecycle>): Observable<ApiResponse<AssetLifecycle>>;
+    getByComponent(componentId: number): Observable<ApiResponse<AssetLifecycle>>;
+    update(lifecycleId: number, data: Partial<AssetLifecycle>): Observable<ApiResponse<AssetLifecycle>>;
+    transition(lifecycleId: number, newStage: string): Observable<ApiResponse<AssetLifecycle>>;
+    assess(lifecycleId: number, data: Record<string, any>): Observable<ApiResponse<AssetLifecycle>>;
+    calculateMetrics(lifecycleId: number): Observable<ApiResponse<AssetLifecycle>>;
+    calculateDepreciation(lifecycleId: number): Observable<ApiResponse<AssetLifecycle>>;
+    getEvents(lifecycleId: number, params?: PaginationParams): Observable<PagedResponse<LifecycleEvent>>;
+    getByStage(stage: string): Observable<ApiResponse<AssetLifecycle[]>>;
+    getApproachingEndOfLife(monthsAhead?: number): Observable<ApiResponse<AssetLifecycle[]>>;
+    getLowHealth(threshold?: number): Observable<ApiResponse<AssetLifecycle[]>>;
+    getRecommendedReplacement(): Observable<ApiResponse<AssetLifecycle[]>>;
+    getDashboard(): Observable<ApiResponse<any>>;
+    getStageEnums(): Observable<ApiResponse<string[]>>;
+    /** Create a lifecycle record via the collection endpoint (wraps data in { data } if needed) */
+    createRecord(data: Record<string, any>): Observable<ApiResponse<AssetLifecycle>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssetLifecycleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssetLifecycleService>;
+}

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

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { AuditEntry } from '../../models/api/misc.models';
+import * as i0 from "@angular/core";
+export declare class AuditEntryService {
+    private http;
+    private readonly basePath;
+    constructor(http: TgmHttpClient);
+    getAuditEntries(entityType: string, entityId: number): Observable<ApiResponse<AuditEntry[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuditEntryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuditEntryService>;
+}

package/lib/services/api/base-crud.service.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, FilterParams, PagedResponse, PaginationParams } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare abstract class BaseCrudService<T, CreateReq = any, UpdateReq = any> {
+    protected http: TgmHttpClient;
+    protected abstract resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getAll(params?: PaginationParams & Record<string, any>): Observable<PagedResponse<T>>;
+    getById(id: number, params?: Record<string, string | number | boolean | undefined>): Observable<ApiResponse<T>>;
+    create(data: CreateReq): Observable<ApiResponse<T>>;
+    update(id: number, data: UpdateReq): Observable<ApiResponse<T>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    count(filters?: FilterParams): Observable<ApiResponse<number>>;
+    duplicate(id: number): Observable<ApiResponse<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseCrudService<any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseCrudService<any, any, any>>;
+}

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

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

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

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

package/lib/services/api/bulk-operation.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 { BulkOperationResponse } from '../../models/api/fleet.models';
+import * as i0 from "@angular/core";
+export declare class BulkOperationService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    bulkUpdateInspectionStatus(ids: number[], status: string): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkDeleteInspections(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkUpdateInterventionStatus(ids: number[], status: string): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkDeleteInterventions(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkUpdateMaintenancePlanStatus(ids: number[], status: string): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkExecuteMaintenancePlans(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkDeleteMaintenancePlans(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkApproveTimeEntries(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkDeleteTimeEntries(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkPauseRecurringEvents(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkResumeRecurringEvents(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkDeleteRecurringEvents(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkUpdateMaterialStatus(ids: number[], status: string): Observable<ApiResponse<BulkOperationResponse>>;
+    bulkDeleteMaterials(ids: number[]): Observable<ApiResponse<BulkOperationResponse>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BulkOperationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BulkOperationService>;
+}

package/lib/services/api/capex-project.service.d.ts

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

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

@@ -0,0 +1,40 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ConditionAssessmentTest, CatPlanningEquipmentItem, CatPersonnelAssignment, CatExecutionResult, CatSignOff, CatAttachment } from '../../models/api/cat.models';
+import * as i0 from "@angular/core";
+export declare class ConditionAssessmentTestService extends BaseCrudService<ConditionAssessmentTest> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionAssessmentTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConditionAssessmentTestService>;
+}
+export declare class CatPlanningEquipmentItemService extends BaseCrudService<CatPlanningEquipmentItem> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatPlanningEquipmentItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatPlanningEquipmentItemService>;
+}
+export declare class CatPersonnelAssignmentService extends BaseCrudService<CatPersonnelAssignment> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatPersonnelAssignmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatPersonnelAssignmentService>;
+}
+export declare class CatExecutionResultService extends BaseCrudService<CatExecutionResult> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatExecutionResultService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatExecutionResultService>;
+}
+export declare class CatSignOffService extends BaseCrudService<CatSignOff> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatSignOffService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatSignOffService>;
+}
+export declare class CatAttachmentService extends BaseCrudService<CatAttachment> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CatAttachmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CatAttachmentService>;
+}

package/lib/services/api/client-article.service.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ClientArticle } from '../../models/api/media.models';
+import { ApiResponse, PagedResponse } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare class ClientArticleService extends BaseCrudService<ClientArticle> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getBySlug(slug: string): Observable<ApiResponse<ClientArticle>>;
+    getFeatured(): Observable<PagedResponse<ClientArticle>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClientArticleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClientArticleService>;
+}

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

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

package/lib/services/api/company-material-type.service.d.ts

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

package/lib/services/api/company-material.service.d.ts

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

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

@@ -0,0 +1,15 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { Company } from '../../models/api/company.models';
+import * as i0 from "@angular/core";
+export declare class CompanyService extends BaseCrudService<Company> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    /** Get the singleton company config (used by many components) */
+    getCompany(params?: any): Observable<any>;
+    /** Update company by ID (preferred — uses standard CRUD path) */
+    updateCompany(data: any, params?: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompanyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CompanyService>;
+}

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

@@ -0,0 +1,35 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { ComplianceObligation, ComplianceSubmission, EnvironmentalPermit, Certification } from '../../models/api/compliance.models';
+import * as i0 from "@angular/core";
+export declare class ComplianceObligationService extends BaseCrudService<ComplianceObligation> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getRiskScores(): Observable<ApiResponse<any[]>>;
+    getRiskScore(id: number): Observable<ApiResponse<any>>;
+    getCalendar(start: string, end: string): Observable<ApiResponse<any[]>>;
+    exportCsv(start: string, end: string): Observable<Blob>;
+    exportPdf(start: string, end: string): Observable<Blob>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComplianceObligationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComplianceObligationService>;
+}
+export declare class ComplianceSubmissionService extends BaseCrudService<ComplianceSubmission> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComplianceSubmissionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComplianceSubmissionService>;
+}
+export declare class EnvironmentalPermitService extends BaseCrudService<EnvironmentalPermit> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnvironmentalPermitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EnvironmentalPermitService>;
+}
+export declare class CertificationService extends BaseCrudService<Certification> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CertificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CertificationService>;
+}

package/lib/services/api/component-info.service.d.ts

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

package/lib/services/api/component-location.service.d.ts

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

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

@@ -0,0 +1,32 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { Component, ComponentGroup, SubAssembly } from '../../models/api/component.models';
+import * as i0 from "@angular/core";
+export declare class ComponentService extends BaseCrudService<Component> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    /**
+     * Get checklist templates associated with a component.
+     */
+    getChecklistTemplates(componentId: number): Observable<ApiResponse<any[]>>;
+    /**
+     * Get failures associated with a component.
+     */
+    getFailures(componentId: number): Observable<ApiResponse<any[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentService>;
+}
+export declare class ComponentGroupService extends BaseCrudService<ComponentGroup> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentGroupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentGroupService>;
+}
+export declare class SubAssemblyService extends BaseCrudService<SubAssembly> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubAssemblyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubAssemblyService>;
+}

package/lib/services/api/cortex-event.service.d.ts

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

package/lib/services/api/cortex-insight.service.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { CortexInsight } from '../../models/api/cortex-insight.models';
+import * as i0 from "@angular/core";
+export declare class CortexInsightService extends BaseCrudService<CortexInsight> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    acknowledge(id: number): Observable<ApiResponse<CortexInsight>>;
+    sendFeedback(id: number, feedback: 'helpful' | 'not_helpful'): Observable<ApiResponse<CortexInsight>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CortexInsightService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CortexInsightService>;
+}

package/lib/services/api/cortex-node.service.d.ts

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

package/lib/services/api/cortex.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 CortexService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getStatus(): Observable<ApiResponse<any>>;
+    buildGraph(locationId: number): Observable<ApiResponse<any>>;
+    analyze(locationId: number): Observable<ApiResponse<any>>;
+    getGraphSummary(): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CortexService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CortexService>;
+}

package/lib/services/api/custom-field.service.d.ts

@@ -0,0 +1,33 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { CustomFieldDefinition, CustomField, CustomForm } from '../../models/api/custom-field.models';
+import * as i0 from "@angular/core";
+export declare class CustomFieldDefinitionService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getFieldTypes(): Observable<ApiResponse<any>>;
+    getByEntityType(entityType: string, activeOnly?: boolean): Observable<ApiResponse<CustomFieldDefinition[]>>;
+    getByName(entityType: string, fieldName: string): Observable<ApiResponse<CustomFieldDefinition>>;
+    create(data: Partial<CustomFieldDefinition>): Observable<ApiResponse<CustomFieldDefinition>>;
+    update(id: number, data: Partial<CustomFieldDefinition>): Observable<ApiResponse<CustomFieldDefinition>>;
+    checkData(id: number): Observable<ApiResponse<any>>;
+    delete(id: number, cleanupData?: boolean): Observable<ApiResponse<void>>;
+    toggle(id: number): Observable<ApiResponse<CustomFieldDefinition>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomFieldDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomFieldDefinitionService>;
+}
+export declare class CustomFieldService extends BaseCrudService<CustomField> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomFieldService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomFieldService>;
+}
+export declare class CustomFormService extends BaseCrudService<CustomForm> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomFormService>;
+}

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

@@ -0,0 +1,23 @@
+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 CustomService {
+    private http;
+    constructor(http: TgmHttpClient);
+    changePassword(data: {
+        currentPassword: string;
+        newPassword: string;
+        confirmPassword: string;
+    }): Observable<ApiResponse<void>>;
+    getLicenseInfo(): Observable<any>;
+    updateLicense(data: any): Observable<any>;
+    createLicense(data: any): Observable<any>;
+    getLicenseStatus(): Observable<any>;
+    queryInflux(query: any): Observable<any>;
+    querySql(query: any): Observable<any>;
+    aiChat(data: any): Observable<any>;
+    aiFeedback(data: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CustomService>;
+}

package/lib/services/api/dashboard.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 DashboardService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getKpis(periodDays?: number): Observable<ApiResponse<any>>;
+    getKpisByRange(startDate: string, endDate: string): Observable<ApiResponse<any>>;
+    getWeeklyKpis(): Observable<ApiResponse<any>>;
+    getMonthlyKpis(): Observable<ApiResponse<any>>;
+    getQuarterlyKpis(): Observable<ApiResponse<any>>;
+    getYearlyKpis(): Observable<ApiResponse<any>>;
+    getUnitKpis(unitId: number, periodDays?: number): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DashboardService>;
+}

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

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { DeferralEvaluation, DeferralConstraintRule, EvaluateDeferralRequest, ConstraintCheckResult } from '../../models/api/deferral.models';
+import * as i0 from "@angular/core";
+export declare class DeferralEvaluationService extends BaseCrudService<DeferralEvaluation> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeferralEvaluationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeferralEvaluationService>;
+}
+export declare class DeferralConstraintRuleService extends BaseCrudService<DeferralConstraintRule> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeferralConstraintRuleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeferralConstraintRuleService>;
+}
+export declare class DeferralDecisionService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    evaluate(request: EvaluateDeferralRequest): Observable<ApiResponse<DeferralEvaluation>>;
+    acceptDecision(evaluationId: number): Observable<ApiResponse<DeferralEvaluation>>;
+    overrideDecision(evaluationId: number, reason: string): Observable<ApiResponse<DeferralEvaluation>>;
+    checkConstraints(unitId: number): Observable<ApiResponse<ConstraintCheckResult[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeferralDecisionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeferralDecisionService>;
+}

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

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

package/lib/services/api/device-gateway.service.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { DeviceGateway } from '../../models/api/iot.models';
+import { ApiResponse, PagedResponse } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare class DeviceGatewayService extends BaseCrudService<DeviceGateway> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getActive(): Observable<PagedResponse<DeviceGateway>>;
+    getByProtocol(protocol: string): Observable<PagedResponse<DeviceGateway>>;
+    heartbeat(id: number): Observable<ApiResponse<DeviceGateway>>;
+    getStale(): Observable<PagedResponse<DeviceGateway>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceGatewayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceGatewayService>;
+}

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

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { DiagnosticReport, DiagnosticReportCreateRequest, DiagnosticReportUpdateRequest } from '../../models/api/diagnostic-report.models';
+import * as i0 from "@angular/core";
+export declare class DiagnosticReportService extends BaseCrudService<DiagnosticReport, DiagnosticReportCreateRequest, DiagnosticReportUpdateRequest> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getByMaintenanceRecord(maintenanceRecordId: number): Observable<ApiResponse<DiagnosticReport[]>>;
+    getByComponent(componentId: number): Observable<ApiResponse<DiagnosticReport[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiagnosticReportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DiagnosticReportService>;
+}

package/lib/services/api/digital-twin.service.d.ts

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+export declare class DigitalTwinService extends BaseCrudService<any> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DigitalTwinService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DigitalTwinService>;
+}
+export declare class ModelService extends BaseCrudService<any> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModelService>;
+}
+export declare class ModelFileService extends BaseCrudService<any> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelFileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModelFileService>;
+}
+export declare class PermissionService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAllPermissions(params?: any): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionService>;
+}