@c8y/ngx-components/operations/operations-list/index.d.ts

Angular modules for Cumulocity IoT applications

import * as i0 from '@angular/core';
import { EnvironmentProviders, OnInit, SimpleChanges } from '@angular/core';
import { TabOrientation, Route, ProductExperienceEventSource, ListItemComponent, ProductExperienceEvent, OperationRealtimeService } from '@c8y/ngx-components';
import { ActivatedRoute, Router } from '@angular/router';
import * as _c8y_client from '@c8y/client';
import { OperationService, SmartRulesService, IOperation, OperationStatus, IResultList } from '@c8y/client';
import { BulkOperationListItemService } from '@c8y/ngx-components/operations/bulk-operation-list-item';
import { OperationsService, OperationStatusOptionsMapShared, OperationStatusOption } from '@c8y/ngx-components/operations/shared';
import { Ng1SmartRulesService } from '@c8y/ngx-components/upgrade/upgraded-services';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Observable } from 'rxjs';
import { StatusFilterComponent } from '@c8y/ngx-components/operations/status-filter';

interface DeviceControlOverviewFeatureConfig {
    path?: string;
    tabLabel?: string;
    tabIcon?: string;
    tabPriority?: number;
    tabOrientation?: TabOrientation;
    navigatorLabel?: string;
    navigatorIcon?: string;
    navigatorPriority?: number;
    navigatorParent?: string;
}
declare const deviceControlOverviewFeatureProviderFactory: (config?: DeviceControlOverviewFeatureConfig) => EnvironmentProviders;
declare const deviceControlTabFeatureProviderFactory: (route?: Partial<Route>) => EnvironmentProviders;

declare class OperationsListService {
    private operationService;
    private smartRulesService;
    private ng1SmartRulesService;
    constructor(operationService: OperationService, smartRulesService: SmartRulesService, ng1SmartRulesService: Ng1SmartRulesService);
    getOperations(customFilter?: {}): Promise<_c8y_client.IResultList<IOperation>>;
    isSmartRulesMicroserviceAvailable(): Promise<boolean>;
    getSmartRulesCreatePermissions(): any;
    createSmartRule(operation: Partial<IOperation>): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OperationsListService, [null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OperationsListService>;
}

declare class OperationsListItemComponent implements OnInit, ProductExperienceEventSource {
    bulkOperationListItemService: BulkOperationListItemService;
    sharedService: OperationsService;
    operationsListService: OperationsListService;
    private route;
    private router;
    operation: Partial<IOperation>;
    collapsed: boolean;
    readOnly: boolean;
    noExpandToggle: boolean;
    isSmartRulesMicroserviceAvailable: boolean;
    listItem: ListItemComponent;
    refreshLoading: boolean;
    OPERATION_STATUS: typeof OperationStatus;
    OPERATION_STATUS_OPTIONS_MAP: OperationStatusOptionsMapShared;
    deviceId: string | number;
    inventoryPermissions: string[];
    smartRuleAdminPermissions: string[];
    operationTitle: string;
    productExperienceEvent: ProductExperienceEvent;
    constructor(bulkOperationListItemService: BulkOperationListItemService, sharedService: OperationsService, operationsListService: OperationsListService, route: ActivatedRoute, router: Router);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    createCustomizedBulkOperation($event?: Event): void;
    private updateOperationTitle;
    static ɵfac: i0.ɵɵFactoryDeclaration<OperationsListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OperationsListItemComponent, "c8y-operations-list-item", never, { "operation": { "alias": "operation"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "noExpandToggle": { "alias": "noExpandToggle"; "required": false; }; "isSmartRulesMicroserviceAvailable": { "alias": "isSmartRulesMicroserviceAvailable"; "required": false; }; }, {}, never, never, true, never>;
}

declare class OperationsListComponent implements ProductExperienceEventSource {
    realtime: OperationRealtimeService;
    private operationsListService;
    private route;
    fragmentType: i0.InputSignal<string>;
    readOnlyItems: i0.InputSignal<boolean>;
    deviceId: string | number;
    OPERATION_STATUS_OPTIONS_MAP: OperationStatusOptionsMapShared;
    title: string;
    refreshLoading: boolean;
    isSmartRulesMicroserviceAvailable: boolean;
    showOverviewBreadcrumbs: boolean;
    statusFilter$: BehaviorSubject<OperationStatusOption[]>;
    reload$: BehaviorSubject<void>;
    statusFilter: StatusFilterComponent;
    operations$: Observable<IResultList<IOperation>>;
    operationsFilterPipe: rxjs.UnaryFunction<Observable<IOperation[]>, Observable<IOperation[]>>;
    productExperienceEvent: ProductExperienceEvent;
    constructor(realtime: OperationRealtimeService, operationsListService: OperationsListService, route: ActivatedRoute);
    ngOnInit(): Promise<void>;
    filter(statusFilters: OperationStatusOption[]): Promise<IResultList<IOperation>>;
    getOperations(filter?: any): Promise<IResultList<IOperation>>;
    compareOperations(operationA: IOperation, operationB: IOperation): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<OperationsListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OperationsListComponent, "c8y-operations-list", never, { "fragmentType": { "alias": "fragmentType"; "required": false; "isSignal": true; }; "readOnlyItems": { "alias": "readOnlyItems"; "required": false; "isSignal": true; }; }, {}, never, ["c8y-help"], true, never>;
}

export { OperationsListComponent, OperationsListItemComponent, OperationsListService, deviceControlOverviewFeatureProviderFactory, deviceControlTabFeatureProviderFactory };
export type { DeviceControlOverviewFeatureConfig };
//# sourceMappingURL=index.d.ts.map