@c8y/ngx-components/operations/stepper-bulk-type-firmware/index.d.ts

Angular modules for Cumulocity IoT applications

import { StepperSelectionEvent } from '@angular/cdk/stepper';
import * as i0 from '@angular/core';
import { OnDestroy, EventEmitter } from '@angular/core';
import { IManagedObject, IResultList, InventoryService } from '@c8y/client';
import { BaseStepperComponent } from '@c8y/ngx-components/operations/bulk-operation-stepper';
import { BulkOperationType, BulkOperationsService, OperationDetails } from '@c8y/ngx-components/operations/bulk-operations-service';
import { TranslateService } from '@ngx-translate/core';
import { BehaviorSubject, Observable } from 'rxjs';
import { RepositoryService, FirmwareBinary } from '@c8y/ngx-components/repository/shared';

declare class StepperBulkTypeFirmwareComponent extends BaseStepperComponent implements OnDestroy {
    private bulkOperationService;
    private translate;
    readonly type: BulkOperationType;
    readonly descriptionTemplate: string;
    textFilter$: BehaviorSubject<string>;
    stepData: {
        firmware: IManagedObject;
        versionOrPatch: IManagedObject;
    };
    selectedFirmware: IManagedObject;
    selectedVersionOrPatch: IManagedObject;
    private subscription;
    constructor(bulkOperationService: BulkOperationsService, translate: TranslateService);
    goToVersionOrPatchStep({ stepper }: {
        stepper: any;
    }): void;
    onVersionOrPatchSelected(versionOrPatch: IManagedObject): void;
    onFirmwareSelected(fw: IManagedObject): void;
    ngOnDestroy(): void;
    protected retrieveOperationPrototype(): OperationDetails;
    protected onSelectionChange(event: StepperSelectionEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperBulkTypeFirmwareComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepperBulkTypeFirmwareComponent, "c8y-stepper-firmware", never, {}, {}, never, never, true, never>;
}

declare class VersionOrPatchComponent {
    private repositoryService;
    private inventoryService;
    private bulkOpsService;
    selected: IManagedObject;
    versionOrPatch: EventEmitter<IManagedObject>;
    elementCount: number;
    DD_LOW_COUNT: number;
    firmware$: Observable<IManagedObject>;
    baseVersions$: Observable<IResultList<IManagedObject>>;
    isLegacy$: Observable<boolean>;
    expanded: {
        [id: string]: boolean;
    };
    constructor(repositoryService: RepositoryService, inventoryService: InventoryService, bulkOpsService: BulkOperationsService);
    getBinaryName$(binaryUrl: any): Observable<string>;
    getBaseVersionAndPatches$(baseVersion: any): Observable<IResultList<IManagedObject> | {
        data: ({
            c8y_Firmware: {
                version: any;
                url: any;
            };
        } & IManagedObject)[];
    }>;
    getPatchVersionsCount$(baseVersion: FirmwareBinary): Observable<number>;
    selectVersionOrPatch(selected: boolean, versionOrPatch: IManagedObject): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VersionOrPatchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VersionOrPatchComponent, "c8y-version-or-patch-step", never, { "selected": { "alias": "selected"; "required": false; }; }, { "versionOrPatch": "versionOrPatch"; }, never, never, true, never>;
}

declare class SelectFirmwareComponent {
    private repositoryService;
    private bulkOpsService;
    private translate;
    selected: IManagedObject;
    firmware: EventEmitter<IManagedObject>;
    elementCount: number;
    DD_LOW_COUNT: number;
    textFilter$: BehaviorSubject<string>;
    firmwares$: Observable<IResultList<IManagedObject>>;
    isLegacy: any;
    readonly DEVICE_TYPE_NOT_AVAILABLE: string;
    readonly DESCRIPTION_NOT_AVAILABLE: string;
    constructor(repositoryService: RepositoryService, bulkOpsService: BulkOperationsService, translate: TranslateService);
    ngOnInit(): void;
    selectFirmware(selected: boolean, fw: IManagedObject): void;
    getBaseVersionsCount$(firmware: IManagedObject): Observable<number | string>;
    getDescriptionTitle(firmware: IManagedObject): string;
    getDeviceTypeTitle(firmware: IManagedObject): string;
    private getFirmwares;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectFirmwareComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectFirmwareComponent, "c8y-select-firmware-step", never, { "selected": { "alias": "selected"; "required": false; }; }, { "firmware": "firmware"; }, never, never, true, never>;
}

/** Module for the 'Firmware update' operation type stepper */
declare class StepperBulkTypeFirmwareModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperBulkTypeFirmwareModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StepperBulkTypeFirmwareModule, never, [typeof StepperBulkTypeFirmwareComponent, typeof VersionOrPatchComponent, typeof SelectFirmwareComponent], [typeof StepperBulkTypeFirmwareComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StepperBulkTypeFirmwareModule>;
}

export { SelectFirmwareComponent, StepperBulkTypeFirmwareComponent, StepperBulkTypeFirmwareModule, VersionOrPatchComponent };
//# sourceMappingURL=index.d.ts.map