@en-solutions/tgm-client-sdk 1.6.21

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

@@ -0,0 +1,28 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { TgFile, TgFolder, Drawing, DrawingCategory } from '../../models/api/document.models';
+import * as i0 from "@angular/core";
+export declare class TgFileService extends BaseCrudService<TgFile> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TgFileService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TgFileService>;
+}
+export declare class TgFolderService extends BaseCrudService<TgFolder> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TgFolderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TgFolderService>;
+}
+export declare class DrawingService extends BaseCrudService<Drawing> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DrawingService>;
+}
+export declare class DrawingCategoryService extends BaseCrudService<DrawingCategory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DrawingCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DrawingCategoryService>;
+}

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

@@ -0,0 +1,41 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, PagedResponse, PaginationParams } from '../../models/base.models';
+import * as i0 from "@angular/core";
+/**
+ * Generic CRUD service for dynamic endpoints where the resource path
+ * is determined at runtime (e.g., CSV import, dynamic data loading).
+ *
+ * Usage:
+ *   this._dynamicCrud.getAll('components', { populate: '*' })
+ *   this._dynamicCrud.getById('sensors', 42)
+ *   this._dynamicCrud.create('units', payload)
+ *   this._dynamicCrud.update('units', 5, payload)
+ *   this._dynamicCrud.delete('units', 5)
+ */
+export declare class DynamicCrudService {
+    private http;
+    constructor(http: TgmHttpClient);
+    /** GET /api/{collection} with optional params */
+    getAll(collection: string, params?: PaginationParams & Record<string, any>): Observable<PagedResponse<any>>;
+    /** GET /api/{collection}/{id} */
+    getById(collection: string, id: number | string, params?: Record<string, any>): Observable<ApiResponse<any>>;
+    /** POST /api/{collection} */
+    create(collection: string, data: any): Observable<ApiResponse<any>>;
+    /** PUT /api/{collection}/{id} */
+    update(collection: string, id: number | string, data: any): Observable<ApiResponse<any>>;
+    /** DELETE /api/{collection}/{id} */
+    remove(collection: string, id: number | string): Observable<ApiResponse<void>>;
+    /** Generic GET for any path */
+    get<T = any>(path: string, params?: Record<string, any>): Observable<T>;
+    /** Generic POST for any path */
+    post<T = any>(path: string, data?: any): Observable<T>;
+    /** Generic PUT for any path */
+    put<T = any>(path: string, data?: any): Observable<T>;
+    /** Upload FormData to any path */
+    upload<T = any>(path: string, formData: FormData): Observable<T>;
+    /** Download blob from any path */
+    download(path: string): Observable<Blob>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicCrudService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicCrudService>;
+}

package/lib/services/api/energy-analytics.service.d.ts

@@ -0,0 +1,16 @@
+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 EnergyAnalyticsService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getAvailability(unitId: number, start: string, end: string): Observable<ApiResponse<any>>;
+    getCostPerMwh(unitId: number, start: string, end: string): Observable<ApiResponse<any>>;
+    getCurtailmentImpact(start: string, end: string): Observable<ApiResponse<any>>;
+    getKpiDashboard(start: string, end: string): Observable<ApiResponse<any>>;
+    getTrends(unitId: number, periodType: string, periods: number): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EnergyAnalyticsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EnergyAnalyticsService>;
+}

package/lib/services/api/energy-production.service.d.ts

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

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

@@ -0,0 +1,46 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { AncillaryService, GridConnection, CurtailmentEvent, OutageEvent, OperatingEvent, SiteAssessment } from '../../models/api/energy.models';
+import * as i0 from "@angular/core";
+export declare class AncillaryServiceCrudService extends BaseCrudService<AncillaryService> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AncillaryServiceCrudService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AncillaryServiceCrudService>;
+}
+export declare class GridConnectionService extends BaseCrudService<GridConnection> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridConnectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridConnectionService>;
+}
+export declare class CurtailmentEventService extends BaseCrudService<CurtailmentEvent> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CurtailmentEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CurtailmentEventService>;
+}
+export declare class OutageEventService extends BaseCrudService<OutageEvent> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getGantt(start: string, end: string): Observable<ApiResponse<any>>;
+    getAnalysis(id: number): Observable<ApiResponse<any>>;
+    getOverlaps(id: number): Observable<ApiResponse<any[]>>;
+    getResourceConflicts(id: number): Observable<ApiResponse<any[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OutageEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OutageEventService>;
+}
+export declare class OperatingEventService extends BaseCrudService<OperatingEvent> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<OperatingEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OperatingEventService>;
+}
+export declare class SiteAssessmentService extends BaseCrudService<SiteAssessment> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SiteAssessmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SiteAssessmentService>;
+}

package/lib/services/api/entity-comment.service.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { EntityComment } from '../../models/api/misc.models';
+import * as i0 from "@angular/core";
+export declare class EntityCommentService {
+    private http;
+    private readonly basePath;
+    constructor(http: TgmHttpClient);
+    getComments(entityType: string, entityId: number): Observable<ApiResponse<EntityComment[]>>;
+    create(comment: Partial<EntityComment>): Observable<ApiResponse<EntityComment>>;
+    update(id: number, comment: Partial<EntityComment>): Observable<ApiResponse<EntityComment>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCommentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityCommentService>;
+}

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

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

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

@@ -0,0 +1,48 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import * as i0 from "@angular/core";
+export declare class ExportService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    exportInspectionsExcel(ids?: number[]): Observable<Blob>;
+    exportInspectionsCsv(ids?: number[]): Observable<Blob>;
+    exportInspectionsPdf(ids?: number[]): Observable<Blob>;
+    exportInterventionsExcel(ids?: number[]): Observable<Blob>;
+    exportInterventionsCsv(ids?: number[]): Observable<Blob>;
+    exportInterventionsPdf(ids?: number[]): Observable<Blob>;
+    exportFailuresExcel(ids?: number[]): Observable<Blob>;
+    exportFailuresCsv(ids?: number[]): Observable<Blob>;
+    exportFailuresPdf(ids?: number[]): Observable<Blob>;
+    exportComponentsExcel(ids?: number[]): Observable<Blob>;
+    exportUnitsExcel(ids?: number[]): Observable<Blob>;
+    exportGateSystemsExcel(ids?: number[]): Observable<Blob>;
+    exportGateSystemsCsv(ids?: number[]): Observable<Blob>;
+    exportGateSystemsPdf(ids?: number[]): Observable<Blob>;
+    exportFishMonitoringExcel(ids?: number[]): Observable<Blob>;
+    exportFishMonitoringCsv(ids?: number[]): Observable<Blob>;
+    exportFishMonitoringPdf(ids?: number[]): Observable<Blob>;
+    exportBathymetricSurveysExcel(ids?: number[]): Observable<Blob>;
+    exportBathymetricSurveysCsv(ids?: number[]): Observable<Blob>;
+    exportBathymetricSurveysPdf(ids?: number[]): Observable<Blob>;
+    exportLaboratoryResultsExcel(ids?: number[]): Observable<Blob>;
+    exportLaboratoryResultsCsv(ids?: number[]): Observable<Blob>;
+    exportLaboratoryResultsPdf(ids?: number[]): Observable<Blob>;
+    exportManualReadingsExcel(ids?: number[]): Observable<Blob>;
+    exportManualReadingsCsv(ids?: number[]): Observable<Blob>;
+    exportManualReadingsPdf(ids?: number[]): Observable<Blob>;
+    exportOperationalObservationsExcel(ids?: number[]): Observable<Blob>;
+    exportOperationalObservationsCsv(ids?: number[]): Observable<Blob>;
+    exportOperationalObservationsPdf(ids?: number[]): Observable<Blob>;
+    exportRegulatoryUpdatesExcel(ids?: number[]): Observable<Blob>;
+    exportRegulatoryUpdatesCsv(ids?: number[]): Observable<Blob>;
+    exportRegulatoryUpdatesPdf(ids?: number[]): Observable<Blob>;
+    exportAIScenariosExcel(ids?: number[]): Observable<Blob>;
+    exportAIScenariosCsv(ids?: number[]): Observable<Blob>;
+    exportAIScenariosPdf(ids?: number[]): Observable<Blob>;
+    exportAlertDefinitionsExcel(ids?: number[]): Observable<Blob>;
+    exportAlertDefinitionsCsv(ids?: number[]): Observable<Blob>;
+    exportAlertDefinitionsPdf(ids?: number[]): Observable<Blob>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportService>;
+}

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

@@ -0,0 +1,24 @@
+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 ExtensionService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<ApiResponse<any[]>>;
+    getAvailable(): Observable<ApiResponse<any[]>>;
+    getByCompany(companyId: number): Observable<ApiResponse<any[]>>;
+    getById(id: number): Observable<ApiResponse<any>>;
+    enable(id: number): Observable<ApiResponse<any>>;
+    disable(id: number): Observable<ApiResponse<any>>;
+    updateConfig(id: number, data: any): Observable<ApiResponse<any>>;
+    getConfig(id: number): Observable<ApiResponse<any>>;
+    validate(id: number): Observable<ApiResponse<any>>;
+    getEvents(id: number): Observable<ApiResponse<any[]>>;
+    getTasks(id: number): Observable<ApiResponse<any[]>>;
+    enableTask(id: number, taskName: string): Observable<ApiResponse<any>>;
+    disableTask(id: number, taskName: string): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExtensionService>;
+}

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

@@ -0,0 +1,28 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { Failure, FailureCause, FailureAction, CorrectiveAction } from '../../models/api/failure.models';
+import * as i0 from "@angular/core";
+export declare class FailureService extends BaseCrudService<Failure> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FailureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FailureService>;
+}
+export declare class FailureCauseService extends BaseCrudService<FailureCause> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FailureCauseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FailureCauseService>;
+}
+export declare class FailureActionService extends BaseCrudService<FailureAction> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FailureActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FailureActionService>;
+}
+export declare class CorrectiveActionService extends BaseCrudService<CorrectiveAction> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CorrectiveActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CorrectiveActionService>;
+}

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

@@ -0,0 +1,71 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, PagedResponse } from '../../models/base.models';
+import { BaseCrudService } from './base-crud.service';
+import { Vehicle, Driver, VehicleTrip, VehicleInspection, VehicleMaintenance, FuelRecord, Geofence, GeofenceEvent, GeofenceCheckResult, GpsLocation, TrackedEntity } from '../../models/api/fleet.models';
+import * as i0 from "@angular/core";
+export declare class VehicleService extends BaseCrudService<Vehicle> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VehicleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VehicleService>;
+}
+export declare class DriverService extends BaseCrudService<Driver> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DriverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DriverService>;
+}
+export declare class VehicleTripService extends BaseCrudService<VehicleTrip> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VehicleTripService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VehicleTripService>;
+}
+export declare class VehicleInspectionService extends BaseCrudService<VehicleInspection> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VehicleInspectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VehicleInspectionService>;
+}
+export declare class VehicleMaintenanceService extends BaseCrudService<VehicleMaintenance> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<VehicleMaintenanceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VehicleMaintenanceService>;
+}
+export declare class FuelRecordService extends BaseCrudService<FuelRecord> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FuelRecordService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FuelRecordService>;
+}
+export declare class GeofenceService extends BaseCrudService<Geofence> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getActiveByCompany(companyId: number): Observable<ApiResponse<Geofence[]>>;
+    checkLocation(companyId: number, latitude: number, longitude: number): Observable<ApiResponse<GeofenceCheckResult[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeofenceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GeofenceService>;
+}
+export declare class GeofenceEventService extends BaseCrudService<GeofenceEvent> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getByCompany(companyId: number, page?: number, pageSize?: number): Observable<PagedResponse<GeofenceEvent>>;
+    getByEntity(entityType: string, entityId: number, companyId: number): Observable<ApiResponse<GeofenceEvent[]>>;
+    getByDateRange(companyId: number, start: string, end: string): Observable<ApiResponse<GeofenceEvent[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeofenceEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GeofenceEventService>;
+}
+export declare class GpsLocationService extends BaseCrudService<GpsLocation> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GpsLocationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GpsLocationService>;
+}
+export declare class TrackedEntityService extends BaseCrudService<TrackedEntity> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrackedEntityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TrackedEntityService>;
+}

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

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

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

@@ -0,0 +1,101 @@
+export { BaseCrudService } from './base-crud.service';
+export { CompanyService } from './company.service';
+export { UnitService } from './unit.service';
+export { ComponentService, ComponentGroupService, SubAssemblyService } from './component.service';
+export { InspectionService, InspectionComponentService } from './inspection.service';
+export { FailureService, FailureCauseService, FailureActionService, CorrectiveActionService } from './failure.service';
+export { InterventionService } from './intervention.service';
+export { MaintenanceRecordService } from './maintenance-record.service';
+export { InterventionRequestService } from './intervention-request.service';
+export { MaterialItemService, MaterialItemHistoryService, MaterialCategoryService, SparePartService } from './material-item.service';
+export { MaterialConsumableService, MaterialConsumableCategoryService, MaterialConsumableHistoryService } from './material-consumable.service';
+export { MaterialInstrumentService, MaterialInstrumentHistoryService } from './material-instrument.service';
+export { MaterialToolingService, MaterialToolingCategoryService, MaterialToolingHistoryService } from './material-tooling.service';
+export { SensorService } from './sensor.service';
+export { AlertService } from './alert.service';
+export { ProjectService } from './project.service';
+export { CapexProjectService } from './capex-project.service';
+export { BudgetService } from './budget.service';
+export { BidService } from './bid.service';
+export { TgFileService, TgFolderService, DrawingService, DrawingCategoryService } from './document.service';
+export { ComplianceObligationService, ComplianceSubmissionService, EnvironmentalPermitService, CertificationService } from './compliance.service';
+export { AncillaryServiceCrudService, GridConnectionService, CurtailmentEventService, OutageEventService, OperatingEventService, SiteAssessmentService } from './energy.service';
+export { WarrantyContractService, WarrantyClaimService } from './warranty.service';
+export { VehicleService, DriverService, VehicleTripService, VehicleInspectionService, VehicleMaintenanceService, FuelRecordService, GeofenceService, GeofenceEventService, GpsLocationService, TrackedEntityService } from './fleet.service';
+export { SlaBreachRecordService } from './sla.service';
+export { ReportingService } from './reporting.service';
+export { BulkOperationService } from './bulk-operation.service';
+export { ArticleService, ArticleCategoryService, ArticleTopicService, BestPracticeService, BestPracticeCategoryService, FaqService, FaqCategoryService, LessonLearnedService, ResourceService, ResourceCategoryService, ResourceTopicService, ModuleService, ModuleLearningService, ModuleVideoService, LearningModuleCategoryService, UserLearningService, TrainingCertificateService, } from './knowledge.service';
+export { RootCauseAnalysisService, SystemicRiskAssessmentService } from './quality.service';
+export { ApprovalWorkflowService as WorkflowService } from './workflow.service';
+export { CustomFieldDefinitionService, CustomFieldService, CustomFormService } from './custom-field.service';
+export { UserService, UserProfileService, UserNotificationService, RoleService, ProfileService, ProfilePermissionService } from './user.service';
+export { CommunityPostService, CommunityCommentService, FeedbackService } from './community.service';
+export { EventService } from './event.service';
+export { LocationService } from './location.service';
+export { DepartmentService } from './department.service';
+export { RoomService } from './room.service';
+export { UploadService } from './upload.service';
+export { SearchService } from './search.service';
+export { AiService } from './ai.service';
+export { AgentService } from './agent.service';
+export { SandboxService } from './sandbox.service';
+export { ExtensionService } from './extension.service';
+export { DashboardService } from './dashboard.service';
+export { ExportService } from './export.service';
+export { TodoService } from './todo.service';
+export { TicketService } from './ticket.service';
+export { NoteService } from './note.service';
+export { LogService } from './log.service';
+export { LoginHistoryService } from './login-history.service';
+export { GateSystemService, AlertDefinitionService, ManualReadingService, LaboratoryResultService, FishMonitoringService, RegulatoryUpdateService, OperationalObservationService, BathymetricSurveyService, AIScenarioService, ReservoirTimeSeriesService, GateControlService, ElevationStorageCurveService, SedimentRemovalOperationService, SedimentManagementPlanService, } from './reservoir.service';
+export { JobTitleService, CountryService, SupplierService, FontService, FormService, FormCategoryService, IncidentService, MessageService, KpiEventService, TurbineTypeService, TermsOfUseService, UnitShutdownHistoryService, PropertyService, PropertiesGroupService, PropertiesTemplateService, MeasurementService, MiHistoryService, MiRequestService, RechargeRequestService, RefurbishmentService, LoginRequestService, MaintenanceJsaService, JsaItemService, JsaStepService, ComponentChecklistService, ComponentChecklistGroupService, ComponentChecklistTemplateService, } from './misc-crud.service';
+export { ClientArticleService } from './client-article.service';
+export { ConditionAssessmentTestService, CatPlanningEquipmentItemService, CatPersonnelAssignmentService, CatExecutionResultService, CatSignOffService, CatAttachmentService, } from './cat.service';
+export { MaintenancePlanService } from './maintenance-plan.service';
+export { RecurringEventService } from './recurring-event.service';
+export { TimeEntryService } from './time-entry.service';
+export { SlaPolicyService } from './sla-policy.service';
+export { AssetLifecycleService } from './asset-lifecycle.service';
+export { InactiveComponentService } from './inactive-component.service';
+export { ComponentLocationService } from './component-location.service';
+export { ComponentInfoService } from './component-info.service';
+export { CompanyMaterialTypeService } from './company-material-type.service';
+export { CompanyMaterialService } from './company-material.service';
+export { WarehouseService, WarehouseStockService } from './warehouse.service';
+export { PurchaseOrderService, GoodsReceiptService, StockMovementService, StockCountService } from './procurement.service';
+export { LicenseService } from './license.service';
+export { WorkPermitService } from './work-permit.service';
+export { DiagnosticReportService } from './diagnostic-report.service';
+export { CustomService } from './custom.service';
+export { DigitalTwinService, ModelService, ModelFileService, PermissionService } from './digital-twin.service';
+export { DynamicCrudService } from './dynamic-crud.service';
+export { UploadWithRefOptions } from './upload.service';
+export { WorkOrderService } from './work-order.service';
+export { PlantDataService } from './plant-data.service';
+export { ReservoirDataService } from './reservoir-data.service';
+export { AiFeedbackService } from './ai-feedback.service';
+export { DeviceGatewayService } from './device-gateway.service';
+export { OutageResourceService } from './outage-resource.service';
+export { EnergyProductionService } from './energy-production.service';
+export { EnergyAnalyticsService } from './energy-analytics.service';
+export { MeasurementUnitService } from './measurement-unit.service';
+export { PropertyTemplateService } from './property-template.service';
+export { AipSettingsService, AipAssessmentService, InvestmentOptionService, AipPlanService, AipScenarioService, AipAnalysisService, AipResourceConstraintService, AipNetworkNodeService, AipPerformanceRecordService, } from './aip.service';
+export { DeferralEvaluationService, DeferralConstraintRuleService, DeferralDecisionService, } from './deferral.service';
+export { CortexService } from './cortex.service';
+export { CortexNodeService } from './cortex-node.service';
+export { CortexEventService } from './cortex-event.service';
+export { CortexInsightService } from './cortex-insight.service';
+export { AipRiskAnalysisService } from './aip-analysis.service';
+export { AipFinancialService } from './aip-financial.service';
+export { AipWorkflowService } from './aip-workflow.service';
+export { AipResourceService } from './aip-resource.service';
+export { AipNetworkAnalysisService } from './aip-network.service';
+export { AipGeographicService } from './aip-geographic.service';
+export { AipPerformanceService } from './aip-performance.service';
+export { AnomalyDetectionService } from './anomaly-detection.service';
+export { ScheduledReportService } from './scheduled-report.service';
+export { EntityCommentService } from './entity-comment.service';
+export { AuditEntryService } from './audit-entry.service';
+export { ThresholdAlertRuleService } from './threshold-alert-rule.service';

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

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

package/lib/services/api/intervention-request.service.d.ts

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

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

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

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

@@ -0,0 +1,106 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { Article, ArticleCategory, ArticleTopic, BestPractice, BestPracticeCategory, Faq, FaqCategory, LessonLearned, Resource, ResourceCategory, ResourceTopic, Module, ModuleLearning, ModuleVideo, LearningModuleCategory, UserLearning, TrainingCertificate } from '../../models/api/knowledge.models';
+import * as i0 from "@angular/core";
+export declare class ArticleService extends BaseCrudService<Article> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArticleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArticleService>;
+}
+export declare class ArticleCategoryService extends BaseCrudService<ArticleCategory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArticleCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArticleCategoryService>;
+}
+export declare class ArticleTopicService extends BaseCrudService<ArticleTopic> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArticleTopicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ArticleTopicService>;
+}
+export declare class BestPracticeService extends BaseCrudService<BestPractice> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BestPracticeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BestPracticeService>;
+}
+export declare class BestPracticeCategoryService extends BaseCrudService<BestPracticeCategory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BestPracticeCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BestPracticeCategoryService>;
+}
+export declare class FaqService extends BaseCrudService<Faq> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FaqService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FaqService>;
+}
+export declare class FaqCategoryService extends BaseCrudService<FaqCategory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FaqCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FaqCategoryService>;
+}
+export declare class LessonLearnedService extends BaseCrudService<LessonLearned> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LessonLearnedService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LessonLearnedService>;
+}
+export declare class ResourceService extends BaseCrudService<Resource> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceService>;
+}
+export declare class ResourceCategoryService extends BaseCrudService<ResourceCategory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceCategoryService>;
+}
+export declare class ResourceTopicService extends BaseCrudService<ResourceTopic> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResourceTopicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResourceTopicService>;
+}
+export declare class ModuleService extends BaseCrudService<Module> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModuleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModuleService>;
+}
+export declare class ModuleLearningService extends BaseCrudService<ModuleLearning> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModuleLearningService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModuleLearningService>;
+}
+export declare class ModuleVideoService extends BaseCrudService<ModuleVideo> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModuleVideoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModuleVideoService>;
+}
+export declare class LearningModuleCategoryService extends BaseCrudService<LearningModuleCategory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LearningModuleCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LearningModuleCategoryService>;
+}
+export declare class UserLearningService extends BaseCrudService<UserLearning> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserLearningService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserLearningService>;
+}
+export declare class TrainingCertificateService extends BaseCrudService<TrainingCertificate> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrainingCertificateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TrainingCertificateService>;
+}

package/lib/services/api/license.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 { License, LicenseInfo } from '../../models/api/company.models';
+import * as i0 from "@angular/core";
+export declare class LicenseService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getInfo(): Observable<ApiResponse<LicenseInfo>>;
+    getStatus(): Observable<ApiResponse<any>>;
+    update(licenseKey: string): Observable<ApiResponse<License>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LicenseService>;
+}