@en-solutions/tgm-client-sdk 1.6.21

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

@@ -0,0 +1,30 @@
+export { ClientAdminService } from './client-admin.service';
+export { ClientApiKeyService } from './client-api-key.service';
+export { PlatformAdminService } from './platform-admin.service';
+export { AnnouncementService } from './announcement.service';
+export { ArticleAdminService } from './article-admin.service';
+export { ErpAdminService } from './erp-admin.service';
+export { EmailProviderAdminService } from './email-provider.service';
+export { MessagingProviderAdminService } from './messaging-provider.service';
+export { IdentityProviderAdminService } from './identity-provider.service';
+export { WebhookAdminService } from './webhook-admin.service';
+export { PlatformWebhookService } from './platform-webhook.service';
+export { QueueAdminService } from './queue-admin.service';
+export { SandboxAdminService } from './sandbox-admin.service';
+export { BackupService } from './backup.service';
+export { RoleAdminService } from './role-admin.service';
+export { UserAdminService } from './user-admin.service';
+export { UserPermissionService } from './user-permission.service';
+export { CacheAdminService } from './cache-admin.service';
+export { AuditLogService } from './audit-log.service';
+export { DocumentAdminService } from './document-admin.service';
+export { ClientOcrService } from './client-ocr.service';
+export { ClientUsageService } from './client-usage.service';
+export { DataExportService } from './data-export.service';
+export { EmailAdminService } from './email-admin.service';
+export { SubscriptionService } from './subscription.service';
+export { SystemHealthService } from './system-health.service';
+export { PlatformNotificationService } from './notification.service';
+export { ImpersonationService } from './impersonation.service';
+export { ActivityLogService } from './activity-log.service';
+export { SchedulerAdminService } from './scheduler-admin.service';

package/lib/services/admin/messaging-provider.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 { MessagingProviderConfigRequest, MessagingProviderConfigResponse } from '../../models/admin/messaging-provider.models';
+import * as i0 from "@angular/core";
+export declare class MessagingProviderAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getTypes(): Observable<any[]>;
+    getChannels(): Observable<any[]>;
+    getSystem(): Observable<MessagingProviderConfigResponse>;
+    getByCompany(companyId: number): Observable<MessagingProviderConfigResponse[]>;
+    getById(id: number): Observable<ApiResponse<MessagingProviderConfigResponse>>;
+    create(data: MessagingProviderConfigRequest): Observable<ApiResponse<MessagingProviderConfigResponse>>;
+    update(id: number, data: Partial<MessagingProviderConfigRequest>): Observable<ApiResponse<MessagingProviderConfigResponse>>;
+    activate(id: number): Observable<ApiResponse<any>>;
+    deactivate(id: number): Observable<ApiResponse<any>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    test(id: number): Observable<ApiResponse<any>>;
+    testMessage(id: number): Observable<ApiResponse<any>>;
+    getStatus(): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessagingProviderAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessagingProviderAdminService>;
+}

package/lib/services/admin/notification.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 PlatformNotificationService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<any[]>;
+    getUnread(): Observable<any[]>;
+    markRead(id: number): Observable<ApiResponse<any>>;
+    markAllRead(): Observable<ApiResponse<any>>;
+    create(data: any): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformNotificationService>;
+}

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

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { PlatformAdminResponse, PlatformAdminCreateRequest, PlatformAdminUpdateRequest } from '../../models/admin/platform-admin.models';
+import * as i0 from "@angular/core";
+export declare class PlatformAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<PlatformAdminResponse[]>;
+    getById(id: number): Observable<ApiResponse<PlatformAdminResponse>>;
+    create(data: PlatformAdminCreateRequest): Observable<ApiResponse<PlatformAdminResponse>>;
+    update(id: number, data: PlatformAdminUpdateRequest): Observable<ApiResponse<PlatformAdminResponse>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    resetPassword(id: number): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformAdminService>;
+}

package/lib/services/admin/platform-webhook.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 PlatformWebhookService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<any[]>;
+    getById(id: number): Observable<ApiResponse<any>>;
+    create(data: any): Observable<ApiResponse<any>>;
+    update(id: number, data: any): Observable<ApiResponse<any>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    test(id: number): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformWebhookService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformWebhookService>;
+}

package/lib/services/admin/queue-admin.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 { QueueResponse, QueueStatsResponse } from '../../models/admin/queue.models';
+import * as i0 from "@angular/core";
+export declare class QueueAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<QueueResponse[]>;
+    getById(id: number): Observable<ApiResponse<QueueResponse>>;
+    create(data: any): Observable<ApiResponse<QueueResponse>>;
+    update(id: number, data: any): Observable<ApiResponse<QueueResponse>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    start(id: number): Observable<ApiResponse<any>>;
+    stop(id: number): Observable<ApiResponse<any>>;
+    pause(id: number): Observable<ApiResponse<any>>;
+    resume(id: number): Observable<ApiResponse<any>>;
+    startAll(): Observable<ApiResponse<any>>;
+    stopAll(): Observable<ApiResponse<any>>;
+    getStatistics(): Observable<QueueStatsResponse>;
+    getHistory(id: number): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueueAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueueAdminService>;
+}

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

@@ -0,0 +1,37 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { RoleRequest, RoleUpdateRequest, RoleResponse, RolePermissionRequest } from '../../models/admin/role.models';
+import * as i0 from "@angular/core";
+export declare class RoleAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<RoleResponse[]>;
+    getById(id: number): Observable<ApiResponse<RoleResponse>>;
+    create(data: RoleRequest): Observable<ApiResponse<RoleResponse>>;
+    update(id: number, data: RoleUpdateRequest): Observable<ApiResponse<RoleResponse>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    setPermissions(id: number, permissions: RolePermissionRequest[]): Observable<ApiResponse<any>>;
+    /** Bulk update permissions for a role (alias for setPermissions) */
+    updatePermissions(roleId: number, permissions: RolePermissionRequest[]): Observable<ApiResponse<any>>;
+    addPermission(id: number, permission: RolePermissionRequest): Observable<ApiResponse<any>>;
+    removePermission(id: number, resourceName: string): Observable<ApiResponse<void>>;
+    getUsers(id: number): Observable<any[]>;
+    clone(id: number, data: any): Observable<ApiResponse<RoleResponse>>;
+    getResourceNames(): Observable<string[]>;
+    getPermissionSummary(id: number): Observable<any>;
+    /** List all roles with permission counts */
+    getRoles(): Observable<RoleResponse[]>;
+    /** Get single role with permissions */
+    getRole(id: number): Observable<ApiResponse<RoleResponse>>;
+    /** Create a new role */
+    createRole(data: RoleRequest): Observable<ApiResponse<RoleResponse>>;
+    /** Update a role */
+    updateRole(id: number, data: RoleUpdateRequest): Observable<ApiResponse<RoleResponse>>;
+    /** Clone a role */
+    cloneRole(id: number): Observable<ApiResponse<RoleResponse>>;
+    /** Get users for a role */
+    getRoleUsers(roleId: number): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoleAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RoleAdminService>;
+}

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

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { SandboxResponse, SandboxStatsResponse } from '../../models/admin/sandbox.models';
+import * as i0 from "@angular/core";
+export declare class SandboxAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<SandboxResponse[]>;
+    getStats(): Observable<SandboxStatsResponse>;
+    getSettings(): Observable<any>;
+    updateSetting(key: string, data: any): Observable<ApiResponse<any>>;
+    updateMaxSandboxes(data: any): Observable<ApiResponse<any>>;
+    updateEnabled(data: any): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SandboxAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SandboxAdminService>;
+}

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

@@ -0,0 +1,61 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import * as i0 from "@angular/core";
+export interface CronJobExecution {
+    id: number;
+    jobName: string;
+    jobGroup?: string;
+    startedAt: string;
+    finishedAt?: string;
+    durationMs?: number;
+    status: 'RUNNING' | 'SUCCESS' | 'FAILED' | 'SKIPPED';
+    itemsProcessed: number;
+    errorMessage?: string;
+    details?: string;
+    tenantId?: string;
+}
+export interface EmailLogEntry {
+    id: number;
+    recipient: string;
+    subject?: string;
+    templateName?: string;
+    status: 'PENDING' | 'SENT' | 'FAILED';
+    provider?: string;
+    sentAt?: string;
+    errorMessage?: string;
+    userId?: number;
+    tenantId?: string;
+    jobExecutionId?: number;
+}
+export interface SchedulerStats {
+    jobsRun24h: number;
+    jobsSuccess24h: number;
+    jobsFailed24h: number;
+    emailsSent24h: number;
+    emailsFailed24h: number;
+    emailsSent7d: number;
+    emailsFailed7d: number;
+}
+export declare class SchedulerAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getStats(): Observable<any>;
+    getSummary(): Observable<any>;
+    getJobNames(): Observable<any>;
+    getExecutions(params?: {
+        page?: number;
+        size?: number;
+        jobName?: string;
+        status?: string;
+    }): Observable<any>;
+    getExecution(id: number): Observable<any>;
+    getEmails(params?: {
+        page?: number;
+        size?: number;
+        recipient?: string;
+        status?: string;
+        jobExecutionId?: number;
+    }): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SchedulerAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SchedulerAdminService>;
+}

package/lib/services/admin/subscription.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 { SubscriptionResponse } from '../../models/admin/client.models';
+import * as i0 from "@angular/core";
+export declare class SubscriptionService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(): Observable<SubscriptionResponse[]>;
+    getByClient(clientId: number): Observable<SubscriptionResponse>;
+    create(clientId: number, data: any): Observable<ApiResponse<SubscriptionResponse>>;
+    cancel(clientId: number): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubscriptionService>;
+}

package/lib/services/admin/system-health.service.d.ts

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

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

@@ -0,0 +1,27 @@
+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";
+export declare class UserAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(params?: PaginationParams): Observable<PagedResponse<any>>;
+    getById(id: number): Observable<ApiResponse<any>>;
+    create(data: any): Observable<ApiResponse<any>>;
+    update(id: number, data: any): Observable<ApiResponse<any>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    block(id: number): Observable<ApiResponse<any>>;
+    unblock(id: number): Observable<ApiResponse<any>>;
+    activate(id: number): Observable<ApiResponse<any>>;
+    deactivate(id: number): Observable<ApiResponse<any>>;
+    updateRole(id: number, data: any): Observable<ApiResponse<any>>;
+    forcePasswordReset(id: number): Observable<ApiResponse<any>>;
+    resendVerification(id: number): Observable<ApiResponse<any>>;
+    invite(data: any): Observable<ApiResponse<any>>;
+    resendInvite(id: number): Observable<ApiResponse<any>>;
+    generateImpersonationCode(): Observable<ApiResponse<any>>;
+    startImpersonation(data: any): Observable<ApiResponse<any>>;
+    verifyImpersonation(data: any): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserAdminService>;
+}

package/lib/services/admin/user-permission.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 UserPermissionService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getAll(userId: number): Observable<any[]>;
+    add(userId: number, data: any): Observable<ApiResponse<any>>;
+    update(userId: number, resourceName: string, data: any): Observable<ApiResponse<any>>;
+    remove(userId: number, resourceName: string): Observable<ApiResponse<void>>;
+    removeAll(userId: number): Observable<ApiResponse<void>>;
+    bulkAdd(userId: number, data: any): Observable<ApiResponse<any>>;
+    getAvailableResources(userId: number): Observable<any[]>;
+    check(userId: number, resourceName: string, action: string): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserPermissionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserPermissionService>;
+}

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

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse } from '../../models/base.models';
+import { WebhookRequest, WebhookUpdateRequest, WebhookResponse, WebhookDeliveryResponse, WebhookTestResponse } from '../../models/admin/webhook.models';
+import * as i0 from "@angular/core";
+export declare class WebhookAdminService {
+    private http;
+    constructor(http: TgmHttpClient);
+    getEventTypes(): Observable<any[]>;
+    getEventTypesByResource(): Observable<any>;
+    getByCompany(companyId: number): Observable<WebhookResponse[]>;
+    getById(id: number): Observable<ApiResponse<WebhookResponse>>;
+    create(data: WebhookRequest): Observable<ApiResponse<WebhookResponse>>;
+    update(id: number, data: WebhookUpdateRequest): Observable<ApiResponse<WebhookResponse>>;
+    delete(id: number): Observable<ApiResponse<void>>;
+    enable(id: number): Observable<ApiResponse<any>>;
+    disable(id: number): Observable<ApiResponse<any>>;
+    regenerateSecret(id: number): Observable<ApiResponse<any>>;
+    test(id: number): Observable<ApiResponse<WebhookTestResponse>>;
+    getDeliveries(id: number): Observable<WebhookDeliveryResponse[]>;
+    getDelivery(deliveryId: number): Observable<ApiResponse<WebhookDeliveryResponse>>;
+    retryDelivery(deliveryId: number): Observable<ApiResponse<any>>;
+    verifySignature(data: any): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebhookAdminService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebhookAdminService>;
+}

package/lib/services/api/agent.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 { AgentChatRequest, AgentChatResponse, AgentHealthResponse, AgentIngestionResponse } from '../../models/api/ai.models';
+import * as i0 from "@angular/core";
+export declare class AgentService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    chat(request: AgentChatRequest): Observable<ApiResponse<AgentChatResponse>>;
+    chatInConversation(id: string, request: AgentChatRequest): Observable<ApiResponse<AgentChatResponse>>;
+    health(): Observable<ApiResponse<AgentHealthResponse>>;
+    ingest(): Observable<ApiResponse<AgentIngestionResponse>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AgentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AgentService>;
+}

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

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

@@ -0,0 +1,36 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { ApiResponse, PagedResponse, PaginationParams } from '../../models/base.models';
+import { AiConversation, AiConversationDetail, AiMessage, CreateAiConversationRequest, UpdateAiConversationRequest } from '../../models/api/ai.models';
+import * as i0 from "@angular/core";
+export declare class AiService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    chat(request: {
+        message: string;
+        conversationId?: string;
+        provider?: string;
+        model?: string;
+    }): Observable<ApiResponse<AiMessage>>;
+    getProviders(): Observable<ApiResponse<any[]>>;
+    getProvider(code: string): Observable<ApiResponse<any>>;
+    getStats(): Observable<ApiResponse<any>>;
+    getConversations(params?: PaginationParams & Record<string, any>): Observable<PagedResponse<AiConversation>>;
+    searchConversations(query: string): Observable<ApiResponse<AiConversation[]>>;
+    createConversation(data: CreateAiConversationRequest): Observable<ApiResponse<AiConversation>>;
+    getConversation(id: string): Observable<ApiResponse<AiConversationDetail>>;
+    updateConversation(id: string, data: UpdateAiConversationRequest): Observable<ApiResponse<AiConversation>>;
+    chatInConversation(id: string, data: {
+        message: string;
+        provider?: string;
+        model?: string;
+    }): Observable<ApiResponse<AiMessage>>;
+    restartConversation(id: string): Observable<ApiResponse<AiConversation>>;
+    forkConversation(id: string): Observable<ApiResponse<AiConversation>>;
+    archiveConversation(id: string): Observable<ApiResponse<AiConversation>>;
+    restoreConversation(id: string): Observable<ApiResponse<AiConversation>>;
+    deleteConversation(id: string): Observable<ApiResponse<void>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AiService>;
+}

package/lib/services/api/aip-analysis.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 { RiskMetrics } from '../../models/api/aip.models';
+import * as i0 from "@angular/core";
+export declare class AipRiskAnalysisService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getRiskMetrics(assessmentId: number): Observable<ApiResponse<RiskMetrics>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipRiskAnalysisService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipRiskAnalysisService>;
+}

package/lib/services/api/aip-financial.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 { CostBenefitAnalysis, LifecycleCostAnalysis, SensitivityAnalysis, PortfolioFinancialMetrics } from '../../models/api/aip.models';
+import * as i0 from "@angular/core";
+export declare class AipFinancialService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getCostBenefitAnalysis(optionId: number): Observable<ApiResponse<CostBenefitAnalysis>>;
+    getLifecycleCostAnalysis(optionId: number): Observable<ApiResponse<LifecycleCostAnalysis>>;
+    getSensitivityAnalysis(optionId: number): Observable<ApiResponse<SensitivityAnalysis>>;
+    getPortfolioMetrics(locationId: number): Observable<ApiResponse<PortfolioFinancialMetrics>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipFinancialService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipFinancialService>;
+}

package/lib/services/api/aip-geographic.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 { GeoAsset, GeographicFilters, RiskHeatmapData, RegionalAnalysis, ProximityAnalysis } from '../../models/api/aip.models';
+import * as i0 from "@angular/core";
+export declare class AipGeographicService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getGeoAssets(locationId: number, filters?: GeographicFilters): Observable<ApiResponse<GeoAsset[]>>;
+    getRiskHeatmap(locationId: number): Observable<ApiResponse<RiskHeatmapData>>;
+    getRegionalAnalysis(locationId: number): Observable<ApiResponse<RegionalAnalysis>>;
+    getProximityAnalysis(assessmentId: number, radiusKm?: number): Observable<ApiResponse<ProximityAnalysis>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipGeographicService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipGeographicService>;
+}

package/lib/services/api/aip-network.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 { LoadForecast, TransmissionConstraint, NetworkBottleneck, PowerFlowAnalysis } from '../../models/api/aip.models';
+import * as i0 from "@angular/core";
+export declare class AipNetworkAnalysisService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getLoadForecasts(locationId: number): Observable<ApiResponse<LoadForecast[]>>;
+    getTransmissionConstraints(locationId: number): Observable<ApiResponse<TransmissionConstraint[]>>;
+    getNetworkBottlenecks(locationId: number): Observable<ApiResponse<NetworkBottleneck[]>>;
+    runPowerFlowAnalysis(locationId: number): Observable<ApiResponse<PowerFlowAnalysis>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipNetworkAnalysisService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipNetworkAnalysisService>;
+}

package/lib/services/api/aip-performance.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 { PerformanceMetrics, EstimationAccuracy, ContinuousImprovementMetric, RootCause } from '../../models/api/aip.models';
+import * as i0 from "@angular/core";
+export declare class AipPerformanceService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getMetrics(locationId: number): Observable<ApiResponse<PerformanceMetrics>>;
+    getEstimationAccuracy(locationId: number): Observable<ApiResponse<EstimationAccuracy>>;
+    getContinuousImprovement(locationId: number): Observable<ApiResponse<ContinuousImprovementMetric[]>>;
+    getRootCauses(recordId: number): Observable<ApiResponse<RootCause[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipPerformanceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipPerformanceService>;
+}

package/lib/services/api/aip-resource.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 { WorkforceCapacity, ContractorResource } from '../../models/api/aip.models';
+import * as i0 from "@angular/core";
+export declare class AipResourceService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getWorkforceCapacity(locationId: number): Observable<ApiResponse<WorkforceCapacity>>;
+    getContractorResources(locationId: number): Observable<ApiResponse<ContractorResource[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipResourceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipResourceService>;
+}

package/lib/services/api/aip-workflow.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 { WorkflowDefinition, PendingApproval, DecisionMetrics } from '../../models/api/aip.models';
+import * as i0 from "@angular/core";
+export declare class AipWorkflowService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    getDefinitions(): Observable<ApiResponse<WorkflowDefinition[]>>;
+    getPendingApprovals(): Observable<ApiResponse<PendingApproval[]>>;
+    getDecisionMetrics(): Observable<ApiResponse<DecisionMetrics>>;
+    submitForApproval(body: {
+        investmentOptionId: number;
+        definitionId: number;
+        submitter: string;
+    }): Observable<ApiResponse<any>>;
+    advanceStage(instanceId: number, body: {
+        decision: string;
+        approver: string;
+    }): Observable<ApiResponse<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipWorkflowService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipWorkflowService>;
+}

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

@@ -0,0 +1,73 @@
+import { Observable } from 'rxjs';
+import { TgmHttpClient } from '../../core/http-client.service';
+import { BaseCrudService } from './base-crud.service';
+import { ApiResponse } from '../../models/base.models';
+import { AipSettings, AipAssessment, InvestmentOption, AipPlan, AipScenario, AipOverview, GeneratePlanRequest, AipResourceConstraint, AipNetworkNode, AipPerformanceRecord, RecordActualsRequest } from '../../models/api/aip.models';
+import * as i0 from "@angular/core";
+export declare class AipSettingsService extends BaseCrudService<AipSettings> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipSettingsService>;
+}
+export declare class AipAssessmentService extends BaseCrudService<AipAssessment> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipAssessmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipAssessmentService>;
+}
+export declare class InvestmentOptionService extends BaseCrudService<InvestmentOption> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<InvestmentOptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InvestmentOptionService>;
+}
+export declare class AipPlanService extends BaseCrudService<AipPlan> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipPlanService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipPlanService>;
+}
+export declare class AipScenarioService extends BaseCrudService<AipScenario> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipScenarioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipScenarioService>;
+}
+export declare class AipResourceConstraintService extends BaseCrudService<AipResourceConstraint> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipResourceConstraintService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipResourceConstraintService>;
+}
+export declare class AipNetworkNodeService extends BaseCrudService<AipNetworkNode> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipNetworkNodeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipNetworkNodeService>;
+}
+export declare class AipPerformanceRecordService extends BaseCrudService<AipPerformanceRecord> {
+    protected resourcePath: string;
+    constructor(http: TgmHttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipPerformanceRecordService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipPerformanceRecordService>;
+}
+export declare class AipAnalysisService {
+    private http;
+    private basePath;
+    constructor(http: TgmHttpClient);
+    analyzeLocation(locationId: number): Observable<any>;
+    getOverview(locationId: number): Observable<ApiResponse<AipOverview>>;
+    generatePlan(request: GeneratePlanRequest): Observable<ApiResponse<AipPlan>>;
+    generateScenarios(planId: number): Observable<ApiResponse<AipScenario[]>>;
+    analyzeFinancial(optionId: number): Observable<ApiResponse<InvestmentOption>>;
+    analyzeAllFinancial(assessmentId: number): Observable<ApiResponse<InvestmentOption[]>>;
+    validateResources(planId: number): Observable<any>;
+    levelResources(planId: number): Observable<any>;
+    validateNetwork(locationId: number): Observable<any>;
+    checkCapacity(locationId: number, additionalMw: number): Observable<any>;
+    recordActuals(optionId: number, request: RecordActualsRequest): Observable<any>;
+    getCalibration(locationId: number): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AipAnalysisService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AipAnalysisService>;
+}