@en-solutions/tgm-client-sdk 1.6.21

package/lib/services/api/location.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 LocationService extends BaseCrudService<any> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocationService>;
+}

package/lib/services/api/log.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 LogService extends BaseCrudService<any> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LogService>;
+}

package/lib/services/api/login-history.service.d.ts

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

package/lib/services/api/maintenance-plan.service.d.ts

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

package/lib/services/api/maintenance-record.service.d.ts

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { MaterialItem, MaterialItemHistory, MaterialCategory, SparePart } from '../../models/api/material.models';
+import * as i0 from "@angular/core";
+export declare class MaterialItemService extends BaseCrudService<MaterialItem> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaterialItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MaterialItemService>;
+}
+export declare class MaterialItemHistoryService extends BaseCrudService<MaterialItemHistory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaterialItemHistoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MaterialItemHistoryService>;
+}
+export declare class MaterialCategoryService extends BaseCrudService<MaterialCategory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaterialCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MaterialCategoryService>;
+}
+export declare class SparePartService extends BaseCrudService<SparePart> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SparePartService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SparePartService>;
+}

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

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

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

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

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

@@ -0,0 +1,167 @@
+import { TgmHttpClient } from '../../core/http-client.service';
+import { JobTitle, Country, Supplier, Font, Incident, Message, KpiEvent, TurbineType, TermsOfUse, UnitShutdownHistory, Property, PropertiesGroup, PropertiesTemplate, Measurement, MiHistory, MiRequest, RechargeRequest, Refurbishment, LoginRequest2, MaintenanceJsa, JsaItem, JsaStep, ComponentChecklist, ComponentChecklistGroup, ComponentChecklistTemplate } from '../../models/api/misc.models';
+import { Form, FormCategory } from '../../models/api/document.models';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+export declare class JobTitleService extends BaseCrudService<JobTitle> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobTitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JobTitleService>;
+}
+export declare class CountryService extends BaseCrudService<Country> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<CountryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CountryService>;
+}
+export declare class SupplierService extends BaseCrudService<Supplier> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SupplierService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SupplierService>;
+}
+export declare class FontService extends BaseCrudService<Font> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FontService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FontService>;
+}
+export declare class FormService extends BaseCrudService<Form> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormService>;
+}
+export declare class FormCategoryService extends BaseCrudService<FormCategory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormCategoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormCategoryService>;
+}
+export declare class IncidentService extends BaseCrudService<Incident> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IncidentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IncidentService>;
+}
+export declare class MessageService extends BaseCrudService<Message> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
+}
+export declare class KpiEventService extends BaseCrudService<KpiEvent> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<KpiEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KpiEventService>;
+}
+export declare class TurbineTypeService extends BaseCrudService<TurbineType> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TurbineTypeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TurbineTypeService>;
+}
+export declare class TermsOfUseService extends BaseCrudService<TermsOfUse> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TermsOfUseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TermsOfUseService>;
+}
+export declare class UnitShutdownHistoryService extends BaseCrudService<UnitShutdownHistory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnitShutdownHistoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UnitShutdownHistoryService>;
+}
+export declare class PropertyService extends BaseCrudService<Property> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertyService>;
+}
+export declare class PropertiesGroupService extends BaseCrudService<PropertiesGroup> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertiesGroupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertiesGroupService>;
+}
+export declare class PropertiesTemplateService extends BaseCrudService<PropertiesTemplate> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<PropertiesTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PropertiesTemplateService>;
+}
+export declare class MeasurementService extends BaseCrudService<Measurement> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MeasurementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MeasurementService>;
+}
+export declare class MiHistoryService extends BaseCrudService<MiHistory> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiHistoryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MiHistoryService>;
+}
+export declare class MiRequestService extends BaseCrudService<MiRequest> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MiRequestService>;
+}
+export declare class RechargeRequestService extends BaseCrudService<RechargeRequest> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RechargeRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RechargeRequestService>;
+}
+export declare class RefurbishmentService extends BaseCrudService<Refurbishment> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RefurbishmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RefurbishmentService>;
+}
+export declare class LoginRequestService extends BaseCrudService<LoginRequest2> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoginRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoginRequestService>;
+}
+export declare class MaintenanceJsaService extends BaseCrudService<MaintenanceJsa> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaintenanceJsaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MaintenanceJsaService>;
+}
+export declare class JsaItemService extends BaseCrudService<JsaItem> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsaItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JsaItemService>;
+}
+export declare class JsaStepService extends BaseCrudService<JsaStep> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsaStepService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JsaStepService>;
+}
+export declare class ComponentChecklistService extends BaseCrudService<ComponentChecklist> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentChecklistService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentChecklistService>;
+}
+export declare class ComponentChecklistGroupService extends BaseCrudService<ComponentChecklistGroup> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentChecklistGroupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentChecklistGroupService>;
+}
+export declare class ComponentChecklistTemplateService extends BaseCrudService<ComponentChecklistTemplate> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentChecklistTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentChecklistTemplateService>;
+}

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

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, PagedResponse, PaginationParams } from '../../models/base.models';
+import { Note } from '../../models/api/misc.models';
+import { BaseCrudService } from './base-crud.service';
+import * as i0 from "@angular/core";
+export declare class NoteService extends BaseCrudService<Note> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getEntityNotes(entityType: string, entityId: number, params?: PaginationParams): Observable<PagedResponse<Note>>;
+    countEntityNotes(entityType: string, entityId: number): Observable<ApiResponse<number>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NoteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NoteService>;
+}

package/lib/services/api/outage-resource.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 { OutageResource } from '../../models/api/energy.models';
+import { ApiResponse, PagedResponse } from '../../models/base.models';
+import * as i0 from "@angular/core";
+export declare class OutageResourceService extends BaseCrudService<OutageResource> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getByOutage(outageEventId: number): Observable<PagedResponse<OutageResource>>;
+    updateStatus(id: number, status: string): Observable<ApiResponse<OutageResource>>;
+    logHours(id: number, hours: number): Observable<ApiResponse<OutageResource>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OutageResourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OutageResourceService>;
+}

package/lib/services/api/plant-data.service.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import * as i0 from "@angular/core";
+export declare class PlantDataService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getUnits(): Observable<any>;
+    getUnit(unitId: number | string): Observable<any>;
+    getActiveAlerts(): Observable<any>;
+    getWaterManagement(): Observable<any>;
+    acknowledgeAlert(alertId: number | string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlantDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlantDataService>;
+}

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

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

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

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

package/lib/services/api/property-template.service.d.ts

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { SlaBreachRecord } from '../../models/api/fleet.models';
+import { ReportDefinition, GeneratedReport, ReportTemplate, ReportStats, GenerateReportRequest, CreateReportDefinitionRequest, UpdateReportDefinitionRequest } from '../../models/api/reporting.models';
+import * as i0 from "@angular/core";
+export declare class ReportingService {
+    private http;
+    private basePath;
+    private advancedPath;
+    constructor(http: TgmHttpClient);
+    getSlaBreachSummary(): Observable<ApiResponse<any>>;
+    getUnresolvedBreaches(): Observable<ApiResponse<SlaBreachRecord[]>>;
+    getBreachesByEntityType(entityType: string): Observable<ApiResponse<SlaBreachRecord[]>>;
+    getRecurringEventSummary(): Observable<ApiResponse<any>>;
+    getDueRecurringEvents(): Observable<ApiResponse<any[]>>;
+    getGeofenceSummary(companyId: number): Observable<ApiResponse<any>>;
+    getGeofenceActivity(companyId: number, start: string, end: string): Observable<ApiResponse<any>>;
+    getTemplates(): Observable<ApiResponse<ReportTemplate[]>>;
+    getTemplate(type: string): Observable<ApiResponse<ReportTemplate>>;
+    createDefinition(data: CreateReportDefinitionRequest): Observable<ApiResponse<ReportDefinition>>;
+    listDefinitions(page?: number, size?: number): Observable<ApiResponse<ReportDefinition[]>>;
+    getDefinition(id: number): Observable<ApiResponse<ReportDefinition>>;
+    updateDefinition(id: number, data: UpdateReportDefinitionRequest): Observable<ApiResponse<ReportDefinition>>;
+    deleteDefinition(id: number): Observable<ApiResponse<void>>;
+    toggleDefinition(id: number, enabled: boolean): Observable<ApiResponse<ReportDefinition>>;
+    generateReport(request: GenerateReportRequest): Observable<ApiResponse<GeneratedReport>>;
+    generateFromDefinition(id: number): Observable<ApiResponse<GeneratedReport>>;
+    listGeneratedReports(page?: number, size?: number): Observable<ApiResponse<GeneratedReport[]>>;
+    getGeneratedReport(id: number): Observable<ApiResponse<GeneratedReport>>;
+    downloadReport(id: number): Observable<Blob>;
+    deleteGeneratedReport(id: number): Observable<ApiResponse<void>>;
+    getReportStats(): Observable<ApiResponse<ReportStats>>;
+    getReport(id: number, font?: string, logo?: string): Observable<Blob>;
+    downloadReportPdf(id: number, font?: string, logo?: string): Observable<Blob>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReportingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReportingService>;
+}

package/lib/services/api/reservoir-data.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 ReservoirDataService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getPlantData(plantId: number | string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReservoirDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReservoirDataService>;
+}

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

@@ -0,0 +1,109 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { GateSystem, AlertDefinition, ManualReading, LaboratoryResult, FishMonitoring, RegulatoryUpdate, OperationalObservation, BathymetricSurvey, AIScenario, TimeSeriesQueryParams, TimeSeriesResponse, GateOperateRequest, AlertAcknowledgeRequest, ElevationStorageCurve, SedimentRemovalOperation, SedimentManagementPlan, TimeSeriesCoverage, InflowForecastResponse } from '../../models/api/reservoir.models';
+import { OperatingEvent } from '../../models/api/energy.models';
+import * as i0 from "@angular/core";
+export declare class GateSystemService extends BaseCrudService<GateSystem> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<GateSystemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GateSystemService>;
+}
+export declare class AlertDefinitionService extends BaseCrudService<AlertDefinition> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertDefinitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertDefinitionService>;
+}
+export declare class ManualReadingService extends BaseCrudService<ManualReading> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ManualReadingService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ManualReadingService>;
+}
+export declare class LaboratoryResultService extends BaseCrudService<LaboratoryResult> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaboratoryResultService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaboratoryResultService>;
+}
+export declare class FishMonitoringService extends BaseCrudService<FishMonitoring> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FishMonitoringService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FishMonitoringService>;
+}
+export declare class RegulatoryUpdateService extends BaseCrudService<RegulatoryUpdate> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RegulatoryUpdateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RegulatoryUpdateService>;
+}
+export declare class OperationalObservationService extends BaseCrudService<OperationalObservation> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<OperationalObservationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OperationalObservationService>;
+}
+export declare class BathymetricSurveyService extends BaseCrudService<BathymetricSurvey> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<BathymetricSurveyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BathymetricSurveyService>;
+}
+export declare class AIScenarioService extends BaseCrudService<AIScenario> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AIScenarioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AIScenarioService>;
+}
+export declare class ReservoirTimeSeriesService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getSensorTimeSeries(reservoirId: string, metric: string, params: TimeSeriesQueryParams): Observable<ApiResponse<TimeSeriesResponse>>;
+    getWeatherTimeSeries(reservoirId: string, params: TimeSeriesQueryParams): Observable<ApiResponse<TimeSeriesResponse>>;
+    getWeatherForecast(reservoirId: string, params: TimeSeriesQueryParams): Observable<ApiResponse<TimeSeriesResponse>>;
+    getGridMarketTimeSeries(reservoirId: string, params: TimeSeriesQueryParams): Observable<ApiResponse<TimeSeriesResponse>>;
+    getGridMarketForecast(reservoirId: string, params: TimeSeriesQueryParams): Observable<ApiResponse<TimeSeriesResponse>>;
+    getGateOperations(gateId: string, params: TimeSeriesQueryParams): Observable<ApiResponse<TimeSeriesResponse>>;
+    getCoverage(reservoirId: number, metric: string): Observable<ApiResponse<TimeSeriesCoverage>>;
+    getInflowForecast(reservoirId: number, params: {
+        start: string;
+        end: string;
+        interval?: string;
+        model?: string;
+        runId?: string;
+    }): Observable<ApiResponse<InflowForecastResponse>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReservoirTimeSeriesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReservoirTimeSeriesService>;
+}
+export declare class GateControlService {
+    private http;
+    constructor(http: TgmHttpClient);
+    operateGate(gateId: string, request: GateOperateRequest): Observable<ApiResponse<OperatingEvent>>;
+    acknowledgeAlert(alertId: number, request: AlertAcknowledgeRequest): Observable<ApiResponse<OperatingEvent>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GateControlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GateControlService>;
+}
+export declare class ElevationStorageCurveService extends BaseCrudService<ElevationStorageCurve> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElevationStorageCurveService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ElevationStorageCurveService>;
+}
+export declare class SedimentRemovalOperationService extends BaseCrudService<SedimentRemovalOperation> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SedimentRemovalOperationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SedimentRemovalOperationService>;
+}
+export declare class SedimentManagementPlanService extends BaseCrudService<SedimentManagementPlan> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    getByLocationId(locationId: number): Observable<ApiResponse<SedimentManagementPlan>>;
+    updateByLocationId(locationId: number, data: any): Observable<ApiResponse<SedimentManagementPlan>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SedimentManagementPlanService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SedimentManagementPlanService>;
+}

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

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