import * as i0 from '@angular/core';
import { OnInit, EventEmitter, OnDestroy, ModuleWithProviders, OnChanges, SimpleChanges, AfterContentInit, TemplateRef } from '@angular/core';
import { Router, ActivatedRoute, ActivatedRouteSnapshot } from '@angular/router';
import * as _c8y_client from '@c8y/client';
import { IManagedObject, IResultList, InventoryService, IOperation } from '@c8y/client';
import { Column, ActionControl, ServerSideDataCallback, DataGridService, ModalService, AlertService, DataSourceModifier, ServerSideDataResult, ValidationPattern, PickedFiles, GainsightService, ServiceRegistry, ISelectModalObject, IUpdateItemEvent } from '@c8y/ngx-components';
import * as i1 from '@c8y/ngx-components/repository/shared';
import { RepositoryService, RepositoryCategory, ModalModel, SoftwareTypeComponent, DeviceSoftwareChange, FilterCriteria, DeviceSoftware } from '@c8y/ngx-components/repository/shared';
import { TranslateService } from '@ngx-translate/core';
import { BsModalService, BsModalRef } from 'ngx-bootstrap/modal';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Subject, Observable } from 'rxjs';
import { NgForm } from '@angular/forms';
import * as i2 from '@c8y/ngx-components/operations/operation-details';

declare class SoftwareListComponent implements OnInit {
    private repositoryService;
    private gridService;
    private modalService;
    private bsModalService;
    private translateService;
    private alertService;
    private router;
    private activatedRoute;
    sizeRequest: Promise<number>;
    sizeRequestDone: boolean;
    refresh$: EventEmitter<void>;
    columns: Column[];
    actionControls: ActionControl[];
    serverSideDataCallback: ServerSideDataCallback;
    pagination: {
        pageSize: number;
        currentPage: number;
    };
    noResultsMessage: "No results to display.";
    noDataMessage: "No software to display.";
    noResultsSubtitle: "Refine your search terms or check your spelling.";
    noDataSubtitle: "Add a new software by clicking below.";
    constructor(repositoryService: RepositoryService, gridService: DataGridService, modalService: ModalService, bsModalService: BsModalService, translateService: TranslateService, alertService: AlertService, router: Router, activatedRoute: ActivatedRoute);
    ngOnInit(): void;
    onDataSourceModifier(dataSourceModifier: DataSourceModifier): Promise<ServerSideDataResult>;
    addSoftware(): void;
    editSoftware(software: Partial<IManagedObject>): void;
    deleteSoftware(software: IManagedObject): Promise<void>;
    trackByName(_index: any, column: Column): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SoftwareListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SoftwareListComponent, "c8y-software-list", never, {}, {}, never, never, true, never>;
}

declare class AddSoftwareModalComponent {
    private modal;
    private repositoryService;
    private alert;
    PRODUCT_EXPERIENCE: {
        readonly SOFTWARE: {
            readonly EVENTS: {
                readonly REPOSITORY: "softwareRepository";
                readonly DEVICE_TAB: "deviceSoftware";
            };
            readonly COMPONENTS: {
                readonly ADD_SOFTWARE_MODAL: "add-software-modal";
                readonly DEVICE_SOFTWARE_CHANGES: "device-software-changes";
                readonly DEVICE_SOFTWARE_LIST: "device-software-list";
            };
            readonly ACTIONS: {
                readonly APPLY_SOFTWARE_CHANGES: "applySoftwareChanges";
                readonly CLEAR_SOFTWARE_CHANGES: "clearSoftwareChanges";
                readonly OPEN_INSTALL_SOFTWARE: "openInstallSoftwareModal";
                readonly OPEN_UPDATE_SOFTWARE: "openUpdateSoftwareModal";
                readonly DELETE_SOFTWARE: "deleteSoftware";
            };
            readonly RESULTS: {
                readonly ADD_SOFTWARE: "addSoftware";
                readonly ADD_SOFTWARE_VERSION: "addSoftwareVersion";
                readonly EDIT_SOFTWARE: "editSoftware";
            };
        };
        readonly FIRMWARE: {
            readonly EVENTS: {
                readonly REPOSITORY: "firmwareRepository";
                readonly DEVICE_TAB: "deviceFirmware";
            };
            readonly COMPONENTS: {
                readonly ADD_FIRMWARE_MODAL: "add-firmware-modal";
                readonly ADD_FIRMWAR_PATCH_MODAL: "add-firmware-patch-modal";
                readonly FIRMWARE_DEVICE_TAB: "firmware-device-tab";
                readonly DEVICE_FIRMWARE_LIST: "device-firmware-list";
            };
            readonly ACTIONS: {
                readonly OPEN_INSTALL_FIRMWARE_DIALOG: "openInstallFirmwareDialog";
                readonly OPEN_REPLACE_FIRMWARE_DIALOG: "openReplaceFirmwareDialog";
                readonly OPEN_INSTALL_FIRMWARE_PATCH_DIALOG: "openInstallFirmwarePatchDialog";
            };
            readonly RESULTS: {
                readonly ADD_FIRMWARE: "addFirmware";
                readonly ADD_FIRMWARE_VERSION: "addFirmwareVersion";
                readonly ADD_FIRMWARE_PATCH: "addFirmwarePatch";
                readonly EDIT_FIRMWARE: "editFirmware";
                readonly CREATE_FIRMWARE_UPDATE_OPERATION: "createFirmwareUpdateOperation";
            };
        };
        readonly SHARED: {
            readonly COMPONENTS: {
                readonly REPOSITORY_SELECT_MODAL: "repository-select-modal";
                readonly SELECT_CONFIGURATION_MODAL: "select-configuration-modal";
            };
        };
    };
    form: NgForm;
    saved: EventEmitter<RepositoryCategory>;
    onInput: BehaviorSubject<string>;
    model: ModalModel;
    softwaresResult: any;
    saving: boolean;
    softwarePreselected: boolean;
    textForSoftwareUrlPopover: string;
    ValidationPattern: typeof ValidationPattern;
    private inputSubscription$;
    constructor(modal: BsModalRef, repositoryService: RepositoryService, alert: AlertService);
    ngOnInit(): void;
    setInitialState(): void;
    loadSoftwares(): void;
    getSoftwareResult(searchStr: string): rxjs.Observable<_c8y_client.IResultList<IManagedObject>>;
    save(): Promise<void>;
    successMsg(): void;
    cancel(): void;
    ngOnDestroy(): void;
    onFile(dropped: PickedFiles): void;
    onSoftwareSelect(software: IManagedObject): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddSoftwareModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddSoftwareModalComponent, "c8y-add-software-software-modal", never, {}, { "saved": "saved"; }, never, never, true, never>;
}

declare class SoftwareDetailsComponent implements OnInit, OnDestroy {
    private activatedRoute;
    private inventoryService;
    private repositoryService;
    private alertService;
    private translateService;
    private modalService;
    private bsModalService;
    private gainsightService;
    private router;
    softwareType: SoftwareTypeComponent;
    reload$: Subject<void>;
    reloading$: BehaviorSubject<boolean>;
    softwareTypeObject: IManagedObject;
    isSoftwareTypeChanged: boolean;
    updateSoftware$: Subject<Partial<IManagedObject>>;
    softwareUpdated$: Subject<IManagedObject>;
    baseVersionsUpdated$: Subject<void>;
    software$: Observable<IManagedObject>;
    baseVersions$: Observable<IResultList<IManagedObject>>;
    isLegacy$: Observable<boolean>;
    destroy$: Subject<boolean>;
    constructor(activatedRoute: ActivatedRoute, inventoryService: InventoryService, repositoryService: RepositoryService, alertService: AlertService, translateService: TranslateService, modalService: ModalService, bsModalService: BsModalService, gainsightService: GainsightService, router: Router);
    ngOnInit(): void;
    getBinaryName$(binaryUrl: any): Observable<string>;
    addBaseVersion(): void;
    deleteBaseVersion(baseVersion: IManagedObject): Promise<void>;
    onSelectSoftwareType(software: any): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SoftwareDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SoftwareDetailsComponent, "c8y-software-details", never, {}, {}, never, never, true, never>;
}

declare class SoftwareRepositoryListModule {
    static forRoot(): ModuleWithProviders<SoftwareRepositoryListModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SoftwareRepositoryListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SoftwareRepositoryListModule, never, [typeof i1.SharedRepositoryModule, typeof SoftwareListComponent, typeof SoftwareDetailsComponent, typeof AddSoftwareModalComponent], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SoftwareRepositoryListModule>;
}

declare class DeviceSoftwareChangesComponent implements OnChanges {
    PRODUCT_EXPERIENCE: {
        readonly SOFTWARE: {
            readonly EVENTS: {
                readonly REPOSITORY: "softwareRepository";
                readonly DEVICE_TAB: "deviceSoftware";
            };
            readonly COMPONENTS: {
                readonly ADD_SOFTWARE_MODAL: "add-software-modal";
                readonly DEVICE_SOFTWARE_CHANGES: "device-software-changes";
                readonly DEVICE_SOFTWARE_LIST: "device-software-list";
            };
            readonly ACTIONS: {
                readonly APPLY_SOFTWARE_CHANGES: "applySoftwareChanges";
                readonly CLEAR_SOFTWARE_CHANGES: "clearSoftwareChanges";
                readonly OPEN_INSTALL_SOFTWARE: "openInstallSoftwareModal";
                readonly OPEN_UPDATE_SOFTWARE: "openUpdateSoftwareModal";
                readonly DELETE_SOFTWARE: "deleteSoftware";
            };
            readonly RESULTS: {
                readonly ADD_SOFTWARE: "addSoftware";
                readonly ADD_SOFTWARE_VERSION: "addSoftwareVersion";
                readonly EDIT_SOFTWARE: "editSoftware";
            };
        };
        readonly FIRMWARE: {
            readonly EVENTS: {
                readonly REPOSITORY: "firmwareRepository";
                readonly DEVICE_TAB: "deviceFirmware";
            };
            readonly COMPONENTS: {
                readonly ADD_FIRMWARE_MODAL: "add-firmware-modal";
                readonly ADD_FIRMWAR_PATCH_MODAL: "add-firmware-patch-modal";
                readonly FIRMWARE_DEVICE_TAB: "firmware-device-tab";
                readonly DEVICE_FIRMWARE_LIST: "device-firmware-list";
            };
            readonly ACTIONS: {
                readonly OPEN_INSTALL_FIRMWARE_DIALOG: "openInstallFirmwareDialog";
                readonly OPEN_REPLACE_FIRMWARE_DIALOG: "openReplaceFirmwareDialog";
                readonly OPEN_INSTALL_FIRMWARE_PATCH_DIALOG: "openInstallFirmwarePatchDialog";
            };
            readonly RESULTS: {
                readonly ADD_FIRMWARE: "addFirmware";
                readonly ADD_FIRMWARE_VERSION: "addFirmwareVersion";
                readonly ADD_FIRMWARE_PATCH: "addFirmwarePatch";
                readonly EDIT_FIRMWARE: "editFirmware";
                readonly CREATE_FIRMWARE_UPDATE_OPERATION: "createFirmwareUpdateOperation";
            };
        };
        readonly SHARED: {
            readonly COMPONENTS: {
                readonly REPOSITORY_SELECT_MODAL: "repository-select-modal";
                readonly SELECT_CONFIGURATION_MODAL: "select-configuration-modal";
            };
        };
    };
    changes: DeviceSoftwareChange[];
    changesInProgress: boolean;
    deviceSoftwareChangesOperation: IOperation;
    clear: EventEmitter<void>;
    drop: EventEmitter<DeviceSoftwareChange>;
    apply: EventEmitter<void>;
    hideSoftwareChanges: EventEmitter<void>;
    get applyButtonLabel(): "Applying changes…" | "Apply changes";
    changes$: BehaviorSubject<DeviceSoftwareChange[]>;
    installations$: rxjs.Observable<DeviceSoftwareChange[]>;
    removals$: rxjs.Observable<DeviceSoftwareChange[]>;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceSoftwareChangesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeviceSoftwareChangesComponent, "c8y-device-software-changes", never, { "changes": { "alias": "changes"; "required": false; }; "changesInProgress": { "alias": "changesInProgress"; "required": false; }; "deviceSoftwareChangesOperation": { "alias": "deviceSoftwareChangesOperation"; "required": false; }; }, { "clear": "clear"; "drop": "drop"; "apply": "apply"; "hideSoftwareChanges": "hideSoftwareChanges"; }, never, never, true, never>;
}

declare class DeviceSoftwareService {
    private serviceRegistry;
    /**
     * Indicates whether device software data is currently being loaded.
     */
    get loading$(): Observable<boolean>;
    private reloadSubject$;
    private loadingSubject$;
    constructor(serviceRegistry: ServiceRegistry);
    /**
     * Trigger device software data reload.
     */
    reload(): void;
    /**
     * Retrieves the software list that is installed on a given device.
     *
     * @param deviceId ID of the device to retrieve software data for
     * @param filterCriteria Criteria that software items are filtered by.
     * @param legacySoftwareList If provided no data will be fetched from backend. The provided software list
     * will be filtered by the specified filter criteria.
     *
     * @returns The software items installed on the specified device filtered by the specified criteria.
     */
    getSoftwareList(deviceId: any, filterCriteria: FilterCriteria, legacySoftwareList?: DeviceSoftware[]): Observable<IResultList<DeviceSoftware>>;
    private getAdvancedSoftwareList;
    private getLegacySoftwareList;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceSoftwareService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DeviceSoftwareService>;
}

declare class DeviceSoftwareListComponent implements OnInit, AfterContentInit, OnDestroy {
    private deviceSoftwareService;
    PRODUCT_EXPERIENCE: {
        readonly SOFTWARE: {
            readonly EVENTS: {
                readonly REPOSITORY: "softwareRepository";
                readonly DEVICE_TAB: "deviceSoftware";
            };
            readonly COMPONENTS: {
                readonly ADD_SOFTWARE_MODAL: "add-software-modal";
                readonly DEVICE_SOFTWARE_CHANGES: "device-software-changes";
                readonly DEVICE_SOFTWARE_LIST: "device-software-list";
            };
            readonly ACTIONS: {
                readonly APPLY_SOFTWARE_CHANGES: "applySoftwareChanges";
                readonly CLEAR_SOFTWARE_CHANGES: "clearSoftwareChanges";
                readonly OPEN_INSTALL_SOFTWARE: "openInstallSoftwareModal";
                readonly OPEN_UPDATE_SOFTWARE: "openUpdateSoftwareModal";
                readonly DELETE_SOFTWARE: "deleteSoftware";
            };
            readonly RESULTS: {
                readonly ADD_SOFTWARE: "addSoftware";
                readonly ADD_SOFTWARE_VERSION: "addSoftwareVersion";
                readonly EDIT_SOFTWARE: "editSoftware";
            };
        };
        readonly FIRMWARE: {
            readonly EVENTS: {
                readonly REPOSITORY: "firmwareRepository";
                readonly DEVICE_TAB: "deviceFirmware";
            };
            readonly COMPONENTS: {
                readonly ADD_FIRMWARE_MODAL: "add-firmware-modal";
                readonly ADD_FIRMWAR_PATCH_MODAL: "add-firmware-patch-modal";
                readonly FIRMWARE_DEVICE_TAB: "firmware-device-tab";
                readonly DEVICE_FIRMWARE_LIST: "device-firmware-list";
            };
            readonly ACTIONS: {
                readonly OPEN_INSTALL_FIRMWARE_DIALOG: "openInstallFirmwareDialog";
                readonly OPEN_REPLACE_FIRMWARE_DIALOG: "openReplaceFirmwareDialog";
                readonly OPEN_INSTALL_FIRMWARE_PATCH_DIALOG: "openInstallFirmwarePatchDialog";
            };
            readonly RESULTS: {
                readonly ADD_FIRMWARE: "addFirmware";
                readonly ADD_FIRMWARE_VERSION: "addFirmwareVersion";
                readonly ADD_FIRMWARE_PATCH: "addFirmwarePatch";
                readonly EDIT_FIRMWARE: "editFirmware";
                readonly CREATE_FIRMWARE_UPDATE_OPERATION: "createFirmwareUpdateOperation";
            };
        };
        readonly SHARED: {
            readonly COMPONENTS: {
                readonly REPOSITORY_SELECT_MODAL: "repository-select-modal";
                readonly SELECT_CONFIGURATION_MODAL: "select-configuration-modal";
            };
        };
    };
    set softwareList(softwareList: DeviceSoftware[]);
    device: IManagedObject;
    deviceSoftwareChanges: DeviceSoftwareChange[];
    filterCriteria$: Observable<FilterCriteria>;
    update: EventEmitter<DeviceSoftware>;
    remove: EventEmitter<DeviceSoftware>;
    onListEmpty: EventEmitter<boolean>;
    softwareItems$: Observable<IResultList<DeviceSoftware>>;
    showUpdate: boolean;
    showRemove: boolean;
    emptyList: boolean;
    noSearchResults: boolean;
    alreadyInstalledMessage: "This software is already installed on the device";
    supportsSoftwareOperations: boolean;
    private readonly operationTypes;
    private legacySoftwareList$;
    private destroyed$;
    constructor(deviceSoftwareService: DeviceSoftwareService);
    ngOnInit(): void;
    ngAfterContentInit(): void;
    isSoftwareGoingToBeChanged(software: DeviceSoftware): boolean;
    ngOnDestroy(): void;
    private notifyListEmpty;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeviceSoftwareListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeviceSoftwareListComponent, "c8y-device-software-list", never, { "softwareList": { "alias": "softwareList"; "required": false; }; "device": { "alias": "device"; "required": false; }; "deviceSoftwareChanges": { "alias": "deviceSoftwareChanges"; "required": false; }; "filterCriteria$": { "alias": "filterCriteria$"; "required": false; }; }, { "update": "update"; "remove": "remove"; "onListEmpty": "onListEmpty"; }, never, [".c8y-empty-state:not(.c8y-no-results-state)", ".c8y-no-results-state"], true, never>;
}

declare class InstalledSoftwareComponent implements OnDestroy, OnInit {
    private repository;
    private bsModal;
    PRODUCT_EXPERIENCE: {
        readonly SOFTWARE: {
            readonly EVENTS: {
                readonly REPOSITORY: "softwareRepository";
                readonly DEVICE_TAB: "deviceSoftware";
            };
            readonly COMPONENTS: {
                readonly ADD_SOFTWARE_MODAL: "add-software-modal";
                readonly DEVICE_SOFTWARE_CHANGES: "device-software-changes";
                readonly DEVICE_SOFTWARE_LIST: "device-software-list";
            };
            readonly ACTIONS: {
                readonly APPLY_SOFTWARE_CHANGES: "applySoftwareChanges";
                readonly CLEAR_SOFTWARE_CHANGES: "clearSoftwareChanges";
                readonly OPEN_INSTALL_SOFTWARE: "openInstallSoftwareModal";
                readonly OPEN_UPDATE_SOFTWARE: "openUpdateSoftwareModal";
                readonly DELETE_SOFTWARE: "deleteSoftware";
            };
            readonly RESULTS: {
                readonly ADD_SOFTWARE: "addSoftware";
                readonly ADD_SOFTWARE_VERSION: "addSoftwareVersion";
                readonly EDIT_SOFTWARE: "editSoftware";
            };
        };
        readonly FIRMWARE: {
            readonly EVENTS: {
                readonly REPOSITORY: "firmwareRepository";
                readonly DEVICE_TAB: "deviceFirmware";
            };
            readonly COMPONENTS: {
                readonly ADD_FIRMWARE_MODAL: "add-firmware-modal";
                readonly ADD_FIRMWAR_PATCH_MODAL: "add-firmware-patch-modal";
                readonly FIRMWARE_DEVICE_TAB: "firmware-device-tab";
                readonly DEVICE_FIRMWARE_LIST: "device-firmware-list";
            };
            readonly ACTIONS: {
                readonly OPEN_INSTALL_FIRMWARE_DIALOG: "openInstallFirmwareDialog";
                readonly OPEN_REPLACE_FIRMWARE_DIALOG: "openReplaceFirmwareDialog";
                readonly OPEN_INSTALL_FIRMWARE_PATCH_DIALOG: "openInstallFirmwarePatchDialog";
            };
            readonly RESULTS: {
                readonly ADD_FIRMWARE: "addFirmware";
                readonly ADD_FIRMWARE_VERSION: "addFirmwareVersion";
                readonly ADD_FIRMWARE_PATCH: "addFirmwarePatch";
                readonly EDIT_FIRMWARE: "editFirmware";
                readonly CREATE_FIRMWARE_UPDATE_OPERATION: "createFirmwareUpdateOperation";
            };
        };
        readonly SHARED: {
            readonly COMPONENTS: {
                readonly REPOSITORY_SELECT_MODAL: "repository-select-modal";
                readonly SELECT_CONFIGURATION_MODAL: "select-configuration-modal";
            };
        };
    };
    device: IManagedObject;
    softwareList: DeviceSoftware[];
    deviceSoftwareChanges: DeviceSoftwareChange[];
    deviceSoftwareChangesInProgress: boolean;
    typesQuery: object;
    changes: EventEmitter<DeviceSoftwareChange[]>;
    showSoftwareChanges: EventEmitter<void>;
    alreadyInstalledWarningTemplate: TemplateRef<any>;
    alreadyInstalledMessage: "{{ name }} (v. {{ version }}) is already installed on this device";
    loadingTemplate: TemplateRef<any>;
    softwareTypeTemplate: TemplateRef<any>;
    showFilter: boolean;
    supportsSoftwareOperations: boolean;
    textFilter$: BehaviorSubject<string>;
    softwareTypeFilter$: BehaviorSubject<string>;
    filterCriteria$: Observable<FilterCriteria>;
    private readonly operationTypes;
    private queriesUtil;
    private modalSearch;
    private destroyed$;
    constructor(repository: RepositoryService, bsModal: BsModalService);
    ngOnInit(): void;
    installSoftware(): void;
    updateSoftware(softwareToUpdate: any): void;
    removeSoftware(softwareToRemove: any): void;
    getInstallableSoftwareListWithVersions$(searchTerm$: BehaviorSubject<FilterCriteria>): Observable<IManagedObject[]>;
    getSingleSoftwareWithVersions$(software: DeviceSoftware): Observable<IManagedObject[]>;
    attachVersions(softwareList: IManagedObject[]): IManagedObject[];
    displaySoftwareSelectModal(initialStateOverrides: any): {
        resultEmitter: EventEmitter<i1.SelectedRepositoryBinary[]>;
        choiceEmitter: EventEmitter<ISelectModalObject>;
        updateInstallableList$: Subject<IUpdateItemEvent<any>>;
    };
    search(filterCriteria: FilterCriteria): void;
    emitSoftwareInstall(items: DeviceSoftware[]): void;
    emitSoftwareRemoval(items: DeviceSoftware[]): void;
    ngOnDestroy(): void;
    private isSoftwareInstalledOnDevicePipe;
    static ɵfac: i0.ɵɵFactoryDeclaration<InstalledSoftwareComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InstalledSoftwareComponent, "c8y-installed-software", never, { "device": { "alias": "device"; "required": false; }; "softwareList": { "alias": "softwareList"; "required": false; }; "deviceSoftwareChanges": { "alias": "deviceSoftwareChanges"; "required": false; }; "deviceSoftwareChangesInProgress": { "alias": "deviceSoftwareChangesInProgress"; "required": false; }; "typesQuery": { "alias": "typesQuery"; "required": false; }; }, { "changes": "changes"; "showSoftwareChanges": "showSoftwareChanges"; }, never, never, true, never>;
}

declare class SoftwareDeviceTabComponent implements OnInit {
    private route;
    private repository;
    private inventory;
    private deviceSoftwareService;
    private serviceRegistry;
    deviceId: string | number;
    device$: BehaviorSubject<IManagedObject>;
    typesQuery$: Observable<object>;
    list$: Observable<DeviceSoftware[]>;
    changes$: BehaviorSubject<DeviceSoftwareChange[]>;
    changesOperation$: BehaviorSubject<IOperation>;
    changesInProgress$: Observable<boolean>;
    reloading: boolean;
    showSoftwareChanges: boolean;
    constructor(route: ActivatedRoute, repository: RepositoryService, inventory: InventoryService, deviceSoftwareService: DeviceSoftwareService, serviceRegistry: ServiceRegistry);
    ngOnInit(): Promise<void>;
    addChanges(requestedChanges: DeviceSoftwareChange[]): void;
    dropChange(changeToBeDropped: DeviceSoftwareChange): void;
    areSameChanges(change1: DeviceSoftwareChange, change2: DeviceSoftwareChange): boolean;
    clearChanges(): void;
    loadDevice(): Promise<void>;
    applyChanges(): Promise<void>;
    private loadOperation;
    private trackOperation;
    private displayChangesFromOperation;
    private isInProgress;
    static ɵfac: i0.ɵɵFactoryDeclaration<SoftwareDeviceTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SoftwareDeviceTabComponent, "c8y-software-device-tab", never, {}, {}, never, never, true, never>;
}

declare class SoftwareDeviceTabGuard {
    private readonly operations;
    canActivate(route: ActivatedRouteSnapshot): any;
    private isAnyOperationSupported;
    static ɵfac: i0.ɵɵFactoryDeclaration<SoftwareDeviceTabGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SoftwareDeviceTabGuard>;
}

declare class SoftwareRepositoryDeviceTabModule {
    static forRoot(): ModuleWithProviders<SoftwareRepositoryDeviceTabModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SoftwareRepositoryDeviceTabModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SoftwareRepositoryDeviceTabModule, never, [typeof i1.SharedRepositoryModule, typeof i2.OperationDetailsModule, typeof SoftwareDeviceTabComponent, typeof InstalledSoftwareComponent, typeof DeviceSoftwareListComponent, typeof DeviceSoftwareChangesComponent], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SoftwareRepositoryDeviceTabModule>;
}

declare class SoftwareRepositoryModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SoftwareRepositoryModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SoftwareRepositoryModule, never, [typeof SoftwareRepositoryDeviceTabModule, typeof SoftwareRepositoryListModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SoftwareRepositoryModule>;
}

export { AddSoftwareModalComponent, DeviceSoftwareChangesComponent, DeviceSoftwareListComponent, DeviceSoftwareService, InstalledSoftwareComponent, SoftwareDetailsComponent, SoftwareDeviceTabComponent, SoftwareDeviceTabGuard, SoftwareListComponent, SoftwareRepositoryDeviceTabModule, SoftwareRepositoryListModule, SoftwareRepositoryModule };
//# sourceMappingURL=index.d.ts.map
