@c8y/ngx-components/ecosystem/index.d.ts

Angular modules for Cumulocity IoT applications

import * as i0 from '@angular/core';
import { OnInit, OnDestroy, ChangeDetectorRef, EventEmitter, SimpleChanges } from '@angular/core';
import * as _c8y_client from '@c8y/client';
import { IApplication, IApplicationBinary, IManagedObject, ApplicationService, InventoryService, IResultList, IApplicationVersion, TenantService, ApplicationAvailability, IManifest } from '@c8y/client';
import * as _c8y_ngx_components from '@c8y/ngx-components';
import { AlertService, PropertiesListItem, Permissions, ModalService, GainsightService, WizardComponent, WizardModalService, PluginsService, TabFactory, Tab, ContextRouteService, DocsService, ApplicationPlugin, PackageType, AppStateService, C8yStepper, OptionsService, TabsService } from '@c8y/ngx-components';
import { BehaviorSubject, Observable } from 'rxjs';
import * as i8 from '@c8y/ngx-components/ecosystem/shared';
import { EcosystemService, ApplicationState, FilterableAppOrPlugin, ListFiltersComponent, FilterPipe, ApplicationPropertiesFormComponent, PackageFilters, PackageAvailabilityService } from '@c8y/ngx-components/ecosystem/shared';
import * as i4 from '@angular/forms';
import { FormGroup, FormBuilder } from '@angular/forms';
import * as i5 from '@angular/router';
import { ActivatedRoute, Router, ActivatedRouteSnapshot } from '@angular/router';
import { TranslateService } from '@ngx-translate/core';
import { BsModalService, BsModalRef } from 'ngx-bootstrap/modal';
import * as i2 from 'ngx-bootstrap/dropdown';
import * as i3 from 'ngx-bootstrap/tooltip';
import * as i6 from 'ngx-bootstrap/popover';
import * as i7 from '@c8y/ngx-components/ecosystem/application-plugins';
import * as i9 from '@c8y/ngx-components/ecosystem/license-confirm';
import * as i10 from '@c8y/ngx-components/icon-selector';
import * as i11 from '@angular/cdk/a11y';
import * as i12 from '@c8y/ngx-components/ecosystem/archived-confirm';

declare class ActivityLogComponent implements OnInit {
    private ecosystemService;
    private alertService;
    application: IApplication;
    hasAdminPermissions: boolean;
    archives: IApplicationBinary[];
    toActivateVersionId: string;
    last: IApplicationBinary;
    isLoading: boolean;
    canReactivate: boolean;
    constructor(ecosystemService: EcosystemService, alertService: AlertService);
    get uploadProgress(): BehaviorSubject<number>;
    ngOnInit(): Promise<void>;
    isActive(archive: IApplicationBinary): boolean;
    toActivate(archive: IApplicationBinary): boolean;
    checkIfLast(archive: IApplicationBinary): boolean;
    showReactivate(): boolean;
    setActive(archive: any): Promise<void>;
    deleteArchive(archive: IApplicationBinary): Promise<void>;
    downloadArchive(archive: IApplicationBinary): Promise<void>;
    reactivateArchive(): Promise<void>;
    onRefresh(): Promise<void>;
    private refresh;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActivityLogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ActivityLogComponent, "c8y-activity-log", never, { "application": { "alias": "application"; "required": false; }; "hasAdminPermissions": { "alias": "hasAdminPermissions"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ApplicationPropertiesComponent implements OnInit {
    private activatedRoute;
    private ecosystemService;
    private router;
    private formBuilder;
    private applicationService;
    private alertService;
    private inventoryService;
    private permissions;
    private modalService;
    private translate;
    private bsModalService;
    private gainsightService;
    CURRENT_LOCATION: string;
    formGroup: FormGroup;
    application: IApplication;
    binaryMo: IManagedObject;
    singleTenant: boolean;
    subscription: boolean;
    canOpenInBrowser: boolean;
    disableOpenInBrowser: boolean;
    canDelete: boolean;
    isOwner: boolean;
    isSubscribed: boolean;
    isPackage: boolean;
    isMicroservice: boolean;
    isFeature: boolean;
    isExternal: boolean;
    isUnpacked: boolean;
    iconMap: {
        HOSTED: string;
        EXTERNAL: string;
        MICROSERVICE: string;
    };
    appState: ApplicationState;
    sourcePackage: IApplication;
    isLoading: boolean;
    isActivityLogSupported: boolean;
    isCustomMicroservice: boolean;
    hasAdminPermissions: boolean;
    noDescriptionLabel: "No description available.";
    breadcrumbConfig: {
        icon: string;
        label: string;
        path: string;
    };
    packageProperties: PropertiesListItem[];
    isUpdateAvailable: boolean;
    private blueprintApplicationVersion;
    constructor(activatedRoute: ActivatedRoute, ecosystemService: EcosystemService, router: Router, formBuilder: FormBuilder, applicationService: ApplicationService, alertService: AlertService, inventoryService: InventoryService, permissions: Permissions, modalService: ModalService, translate: TranslateService, bsModalService: BsModalService, gainsightService: GainsightService);
    ngOnInit(): Promise<void>;
    refresh(): Promise<void>;
    load(): Promise<void>;
    onApplication(app: IApplication): void;
    cancel(): void;
    openApp(app: any): void;
    getPackage(entityOrId: string | number | IApplication): Promise<_c8y_client.IResult<IApplication>>;
    delete(): Promise<void>;
    subscribe(): Promise<void>;
    unsubscribe(): Promise<void>;
    loadApplication(): Promise<void>;
    save(app: IApplication): Promise<void>;
    onNewArchive(): void;
    updateToLatestVersion(): Promise<void>;
    private getDescription;
    private confirmSubscriptionChange;
    private resolveSourcePackageDetails;
    private initForm;
    private isActivityLogSupportedByApp;
    private setBreadcrumbConfig;
    private loadBinaryMo;
    private extractVersionInformation;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationPropertiesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationPropertiesComponent, "c8y-application-properties", never, {}, {}, never, never, true, never>;
}

declare class ApplicationPropertiesGuard {
    private ecosystemService;
    constructor(ecosystemService: EcosystemService);
    canActivate(route: ActivatedRouteSnapshot): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationPropertiesGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationPropertiesGuard>;
}

declare class AddExternalApplicationComponent implements OnInit {
    private applicationService;
    private formBuilder;
    private alertService;
    private wizardComponent;
    formGroup: FormGroup;
    createdApp: IApplication;
    constructor(applicationService: ApplicationService, formBuilder: FormBuilder, alertService: AlertService, wizardComponent: WizardComponent);
    ngOnInit(): void;
    back(): void;
    cancel(): void;
    done(): void;
    save(app: IApplication): Promise<void>;
    private initForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddExternalApplicationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddExternalApplicationComponent, "c8y-add-external-application", never, {}, {}, never, never, true, never>;
}

declare class AddWebApplicationComponent {
    private ecosystemService;
    headerText: string;
    successText: string;
    constructor(ecosystemService: EcosystemService);
    createApplicationHandler: (f: File) => Promise<IApplication>;
    uploadApplicationHandler: (f: File, app: IApplication) => Promise<IApplication>;
    createApplication(file: File): Promise<IApplication>;
    uploadApplication(file: File, app: IApplication): Promise<IApplication>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddWebApplicationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddWebApplicationComponent, "c8y-add-web-application", never, {}, {}, never, never, true, never>;
}

declare class ApplicationListComponent implements OnInit, OnDestroy {
    private ecosystemService;
    private wizardModalService;
    reloading: boolean;
    reload$: BehaviorSubject<void>;
    apps$: Observable<IApplication[]>;
    filteredApps$: Observable<FilterableAppOrPlugin[]>;
    listClass: string;
    packageAvailabilities: ("Subscribed`application`" | "Unpacked`application`" | "External`application`" | "Custom`application`")[];
    filtersComponent: ListFiltersComponent;
    private destroy$;
    constructor(ecosystemService: EcosystemService, wizardModalService: WizardModalService);
    ngOnInit(): void;
    loadApplications(): void;
    addApplication(): void;
    ngOnDestroy(): void;
    setFilterPipe(pipe: FilterPipe): void;
    resetFilters(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationListComponent, "c8y-application-list", never, {}, {}, never, never, true, never>;
}

declare class InstallFromPackageComponent implements OnInit {
    private ecosystemService;
    private applicationService;
    private wizardComponent;
    private pluginsService;
    newAppConfig: IApplication;
    selectedPackage: IApplication;
    packages: IApplication[];
    inProgress: boolean;
    deployedWithSuccess: boolean;
    isDeployed: boolean;
    model: {
        selected: any;
        binary: {
            id: any;
        };
    };
    canDeploy: boolean;
    onInput: BehaviorSubject<string>;
    versions$: Observable<IResultList<IApplicationVersion>>;
    applicationPropertiesForm: ApplicationPropertiesFormComponent;
    constructor(ecosystemService: EcosystemService, applicationService: ApplicationService, wizardComponent: WizardComponent, pluginsService: PluginsService);
    ngOnInit(): Promise<void>;
    back(): void;
    clean(): void;
    cancel(): void;
    deployApp(): Promise<void>;
    onAppVersionSelect(appVersion: IApplicationVersion): void;
    selectPackage(selectedPackage: IApplication): Promise<void>;
    private loadSelectedPackageVersions;
    private getAppVersions;
    private setInitialValueForInput;
    private filterAppVersions;
    private markAsDeployed;
    private loadPackages;
    static ɵfac: i0.ɵɵFactoryDeclaration<InstallFromPackageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InstallFromPackageComponent, "c8y-install-from-package", never, {}, {}, never, never, true, never>;
}

declare class EcosystemTabs implements TabFactory {
    router: Router;
    ecosystemTabs: Tab[];
    constructor(router: Router);
    get(): Tab[];
    static ɵfac: i0.ɵɵFactoryDeclaration<EcosystemTabs, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EcosystemTabs>;
}

declare class PackageChangelogTabComponent implements OnInit {
    private activatedRoute;
    private contextRouteService;
    package: IApplication;
    constructor(activatedRoute: ActivatedRoute, contextRouteService: ContextRouteService);
    ngOnInit(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageChangelogTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageChangelogTabComponent, "c8y-package-changelog-tab", never, {}, {}, never, never, true, never>;
}

declare class MicroserviceListComponent implements OnInit {
    private ecosystemService;
    private wizardModalService;
    private cd;
    reloading: boolean;
    reload$: BehaviorSubject<void>;
    microservices$: Observable<IApplication[]>;
    filteredMicroservices$: Observable<FilterableAppOrPlugin[]>;
    isMicroserviceHostingAllowed$: Observable<boolean>;
    listClass: string;
    packageAvailabilities: (keyof PackageFilters['availability'])[];
    filtersComponent: ListFiltersComponent;
    constructor(ecosystemService: EcosystemService, wizardModalService: WizardModalService, cd: ChangeDetectorRef);
    ngOnInit(): void;
    loadMicroservices(): void;
    addMicroservice(): void;
    setFilterPipe(pipe: FilterPipe): void;
    resetFilters(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MicroserviceListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MicroserviceListComponent, "c8y-microservice-list", never, {}, {}, never, never, true, never>;
}

declare class AddMicroserviceComponent {
    private ecosystemService;
    private modal;
    private tenantService;
    private docs;
    readonly slaHref: any;
    headerText: string;
    successText: string;
    constructor(ecosystemService: EcosystemService, modal: ModalService, tenantService: TenantService, docs: DocsService);
    createMicroserviceApplicationHandler: (f: File) => Promise<IApplication>;
    uploadMicroserviceHandler: (f: File, app: IApplication) => Promise<void>;
    createMicroserviceApplication(file: File): Promise<IApplication>;
    uploadMicroservice(file: File, microservice: IApplication): Promise<void>;
    private askIfActivationAfterUploadNeeded;
    private subscribeMicroservice;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddMicroserviceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddMicroserviceComponent, "c8y-add-microservice", never, {}, {}, never, never, true, never>;
}

declare class PackagesListComponent implements OnDestroy {
    private ecosystemService;
    private wizardModalService;
    private permissions;
    reloading: boolean;
    reload$: BehaviorSubject<void>;
    packages$: Observable<IApplication[]>;
    filteredPackages$: Observable<FilterableAppOrPlugin[]>;
    listClass: string;
    hasAdminPermissions: boolean;
    emptyStateSubtitle: "Add your first package by clicking below.";
    packageTypes: (_c8y_ngx_components.PackageType.OFFICIAL | _c8y_ngx_components.PackageType.COMMUNITY)[];
    packageAvailabilities: (keyof PackageFilters['availability'])[];
    packageContents: ("Blueprint" | "Plugins")[];
    filtersComponent: ListFiltersComponent;
    private destroy$;
    constructor(ecosystemService: EcosystemService, wizardModalService: WizardModalService, permissions: Permissions);
    ngOnInit(): void;
    loadPackages(): void;
    addPackage(): void;
    ngOnDestroy(): void;
    setFilterPipe(pipe: FilterPipe): void;
    resetFilters(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackagesListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackagesListComponent, "c8y-packages-list", never, {}, {}, never, never, true, never>;
}

declare class PackageDetailsComponent implements OnInit {
    private activatedRoute;
    private wizardModalService;
    private ecosystemService;
    private contextRouteService;
    private pluginsService;
    private packageAvailabilityService;
    private ui;
    private gainsightService;
    markdown: string;
    pluginMarkdown: string;
    baseUrl: string;
    pluginBaseUrl: string;
    package: IApplication;
    name: string;
    description: string;
    appState: ApplicationState;
    isPackageBlueprint: boolean;
    exportedPlugins$: BehaviorSubject<ApplicationPlugin[]>;
    isChangingAvailability: boolean;
    isOwnedByCurrentTenant: boolean;
    isAllowedToCreateSubtenants: boolean;
    packageContentState: ApplicationState;
    packageType: PackageType;
    packageAvailability: ApplicationAvailability;
    selectedPlugin: ApplicationPlugin;
    readonly packageTypeLabels: {
        COMMUNITY: {
            label: "COMMUNITY`Package created by the developer community.`";
            tooltip: "Package created by the developer community.";
        };
        OFFICIAL: {
            label: "OFFICIAL`Package maintained by Cumulocity.`";
            tooltip: "Package maintained by Cumulocity.";
        };
        UNKNOWN: {
            label: "CUSTOM`Package maintained by an unknown source.`";
            tooltip: "Package maintainer unknown.";
        };
        ARCHIVED: {
            label: "ARCHIVED`Package out of maintenance.`";
            tooltip: "The package was marked by the author as archived.";
        };
    };
    readonly PACKAGE_TYPE: typeof PackageType;
    readonly packageProperties: PropertiesListItem[];
    constructor(activatedRoute: ActivatedRoute, wizardModalService: WizardModalService, ecosystemService: EcosystemService, contextRouteService: ContextRouteService, pluginsService: PluginsService, packageAvailabilityService: PackageAvailabilityService, ui: AppStateService, gainsightService: GainsightService);
    ngOnInit(): Promise<void>;
    deploy(): void;
    togglePackageAvailability(pckg: IApplication, newAvailability: ApplicationAvailability): Promise<void>;
    showPluginOverview(plugin: ApplicationPlugin): Promise<void>;
    closeOverview(): void;
    private loadData;
    private extractPackageMFExports;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageDetailsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageDetailsComponent, "c8y-package-details", never, {}, {}, never, never, true, never>;
}

declare class DeployApplicationComponent implements OnInit {
    private ecosystemService;
    private wizardComponent;
    private translate;
    private pluginService;
    private gainsightService;
    private router;
    CURRENT_LOCATION: string;
    inProgress: boolean;
    package: IApplication;
    isDeployed: boolean;
    deployedWithSuccess: boolean;
    newAppConfig: IApplication;
    deployedApp: IApplication;
    applicationHref: string;
    model: {
        selected: any;
        binary: {
            id: any;
        };
    };
    canDeploy: boolean;
    applicationPropertiesForm: ApplicationPropertiesFormComponent;
    readonly descriptionTemplate: string;
    readonly successMessageTemplate: "Application \"{{ packageName }}\" created";
    readonly doneLabel: "Done";
    readonly cancelLabel: "Cancel";
    headerText: string;
    constructor(ecosystemService: EcosystemService, wizardComponent: WizardComponent, translate: TranslateService, pluginService: PluginsService, gainsightService: GainsightService, router: Router);
    ngOnInit(): Promise<void>;
    deployApp(): Promise<void>;
    cancel(): void;
    onAppVersionSelect(appVersion: IApplicationVersion): void;
    open(): void;
    private markAsDeployed;
    private getHeaderText;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeployApplicationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DeployApplicationComponent, "c8y-deploy-application", never, {}, {}, never, never, true, never>;
}

declare class AddPackageComponent {
    private ecosystemService;
    stepper: C8yStepper;
    headerText: string;
    successText: string;
    constructor(ecosystemService: EcosystemService);
    createPackageAppHandler: (f: File) => Promise<IApplication>;
    uploadPackageHandler: (f: File, app: IApplication) => Promise<IApplication>;
    createPackageApp(file: File): Promise<IApplication>;
    uploadPackage(file: File, pckg: IApplication): Promise<IApplication>;
    next(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddPackageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddPackageComponent, "c8y-add-package", never, {}, {}, never, never, true, never>;
}

declare class FeatureListComponent {
    private ecosystemService;
    reloading: boolean;
    reload$: BehaviorSubject<void>;
    features$: Observable<IApplication[]>;
    filteredFeatures$: Observable<FilterableAppOrPlugin[]>;
    listClass: string;
    filtersComponent: ListFiltersComponent;
    constructor(ecosystemService: EcosystemService);
    ngOnInit(): void;
    loadFeatures(): void;
    setFilterPipe(pipe: FilterPipe): void;
    resetFilters(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FeatureListComponent, "c8y-feature-list", never, {}, {}, never, never, true, never>;
}

declare class PackageVersionsComponent {
    private activatedRoute;
    private contextRouteService;
    private pluginsService;
    package: IApplication;
    selectedVersion: string;
    selectedPlugin: ApplicationPlugin;
    pluginBaseUrl: string;
    pluginMarkdown: string;
    packageContentsTitle: "Version {{ selectedVersion }} package contents";
    constructor(activatedRoute: ActivatedRoute, contextRouteService: ContextRouteService, pluginsService: PluginsService);
    ngOnInit(): Promise<void>;
    showPluginOverview(plugin: ApplicationPlugin): Promise<void>;
    closeOverview(): void;
    clearSelectedVersion(): void;
    selectVersion(version: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageVersionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageVersionsComponent, "c8y-package-versions", never, {}, {}, never, never, true, never>;
}

declare class PackageVersionsPluginsComponent {
    private activatedRoute;
    selectedVersionManifest: IManifest;
    selectedPlugin: ApplicationPlugin;
    showOverview: EventEmitter<ApplicationPlugin>;
    exportedPlugins$: BehaviorSubject<ApplicationPlugin[]>;
    private appParentData;
    constructor(activatedRoute: ActivatedRoute);
    ngOnChanges(): Promise<void>;
    showPluginOverview(plugin: ApplicationPlugin): void;
    private getExportedPlugins;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageVersionsPluginsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageVersionsPluginsComponent, "c8y-contents-plugins", never, { "selectedVersionManifest": { "alias": "selectedVersionManifest"; "required": false; }; "selectedPlugin": { "alias": "selectedPlugin"; "required": false; }; }, { "showOverview": "showOverview"; }, never, never, true, never>;
}

declare class PackageVersionsAppsComponent {
    selectedVersionManifest: IManifest;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageVersionsAppsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageVersionsAppsComponent, "c8y-contents-apps", never, { "selectedVersionManifest": { "alias": "selectedVersionManifest"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PackageContentsComponent {
    private activatedRoute;
    private applicationService;
    private alertService;
    private contextRouteService;
    selectedVersion: string;
    selectedPlugin: ApplicationPlugin;
    showOverview: EventEmitter<ApplicationPlugin>;
    selectedVersionManifest: IManifest;
    package: IApplication;
    isLoading: boolean;
    previousVersion: string | null;
    readonly packageVersionProperties: PropertiesListItem[];
    constructor(activatedRoute: ActivatedRoute, applicationService: ApplicationService, alertService: AlertService, contextRouteService: ContextRouteService);
    showPluginOverview(plugin: ApplicationPlugin): void;
    ngOnChanges(changes: SimpleChanges): Promise<void>;
    loadManifest(version: string): Promise<void>;
    private getManifest;
    private getPreviousVersion;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageContentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageContentsComponent, "c8y-package-contents", never, { "selectedVersion": { "alias": "selectedVersion"; "required": false; }; "selectedPlugin": { "alias": "selectedPlugin"; "required": false; }; }, { "showOverview": "showOverview"; }, never, never, true, never>;
}

declare class PackageVersionsListComponent implements OnInit {
    private activatedRoute;
    private pluginsService;
    private ecosystemService;
    private translateService;
    private modal;
    private alertService;
    private optionsService;
    private permissions;
    private gainsightService;
    CURRENT_LOCATION: string;
    versionsLimit: number;
    isLoading: boolean;
    package: IApplication;
    sortedVersions: IApplicationVersion[];
    selectedVersion: string;
    preUploadCallback: () => Promise<any>;
    hasAdminPermissions: boolean;
    isPackageOwnedByCurrentTenant: boolean;
    onVersionSelect: EventEmitter<string>;
    constructor(activatedRoute: ActivatedRoute, pluginsService: PluginsService, ecosystemService: EcosystemService, translateService: TranslateService, modal: ModalService, alertService: AlertService, optionsService: OptionsService, permissions: Permissions, gainsightService: GainsightService);
    ngOnInit(): Promise<void>;
    downloadArchive(appVersion: IApplicationVersion): Promise<void>;
    packageVersionUploaded(): void;
    selectVersion(version: string | null): void;
    removeVersionPackage(version: string): Promise<void>;
    setVersionAsLatest(appVersion: IApplicationVersion): Promise<void>;
    acknowledgeLimitReached(): Promise<void>;
    private refreshPackage;
    private sortVersions;
    private setUploadedVersionAsLatest;
    private toggleUploadPossibility;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageVersionsListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageVersionsListComponent, "c8y-package-versions-list", never, {}, { "onVersionSelect": "onVersionSelect"; }, never, never, true, never>;
}

declare class SubscriptionModalComponent implements OnInit {
    private bsModalRef;
    private ecosystemService;
    private tabsService;
    private modal;
    private applicationService;
    private alertService;
    private contextRouteService;
    readonly RETRY_TIMEOUT = 3000;
    application: IApplication;
    message: string;
    isLoading: boolean;
    result: Promise<void>;
    isSubscribed: boolean;
    retryCounter: number;
    private readonly TABS;
    private _resolve;
    constructor(bsModalRef: BsModalRef, ecosystemService: EcosystemService, tabsService: TabsService, modal: ModalService, applicationService: ApplicationService, alertService: AlertService, contextRouteService: ContextRouteService);
    ngOnInit(): void;
    subscribe(): Promise<void>;
    unsubscribe(): Promise<void>;
    private getStatusDetails;
    private onSubscribe;
    private shouldShowMSSpecificTabs;
    private onUnsubscribe;
    private hideSubscriptionModal;
    private showWarningModal;
    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptionModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptionModalComponent, "c8y-subscription-modal", never, {}, {}, never, never, true, never>;
}

declare class UpdateApplicationModalComponent implements OnInit {
    private inventoryService;
    private ecosystemService;
    private pluginsService;
    private modal;
    isUpdateOngoing: boolean;
    updateFailure: boolean;
    sourcePackage: IApplication;
    application: IApplication;
    result: Promise<void>;
    orphanedPlugins$: BehaviorSubject<ApplicationPlugin[]>;
    newPlugins$: BehaviorSubject<ApplicationPlugin[]>;
    private _resolve;
    private _reject;
    constructor(inventoryService: InventoryService, ecosystemService: EcosystemService, pluginsService: PluginsService);
    ngOnInit(): void;
    /**
     * Checks if there is a delta between the current application and the source package remotes.
     * @returns {boolean} true if there is a delta between the current application and the source package remotes.
     */
    getRemoteDelta(): boolean;
    close(): void;
    done(): void;
    updateApplication(): Promise<void>;
    private getAllRemotesToAdd;
    private getAllRemotesToRemove;
    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateApplicationModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UpdateApplicationModalComponent, "c8y-update-application-modal", never, {}, {}, never, never, true, never>;
}

declare class EcosystemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<EcosystemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<EcosystemModule, never, [typeof _c8y_ngx_components.CoreModule, typeof i2.BsDropdownModule, typeof i3.TooltipModule, typeof _c8y_ngx_components.FormsModule, typeof i4.ReactiveFormsModule, typeof i5.RouterModule, typeof i6.PopoverModule, typeof i7.ApplicationPluginsModule, typeof i8.SharedEcosystemModule, typeof i9.LicenseConfirmModule, typeof i10.IconSelectorModule, typeof i11.A11yModule, typeof i12.ArchivedConfirmModule, typeof PackageChangelogTabComponent, typeof ApplicationListComponent, typeof MicroserviceListComponent, typeof ApplicationPropertiesComponent, typeof AddMicroserviceComponent, typeof ActivityLogComponent, typeof AddWebApplicationComponent, typeof AddExternalApplicationComponent, typeof InstallFromPackageComponent, typeof PackagesListComponent, typeof PackageDetailsComponent, typeof DeployApplicationComponent, typeof AddPackageComponent, typeof FeatureListComponent, typeof PackageVersionsComponent, typeof PackageVersionsPluginsComponent, typeof PackageVersionsAppsComponent, typeof PackageContentsComponent, typeof PackageVersionsListComponent, typeof SubscriptionModalComponent, typeof UpdateApplicationModalComponent], [typeof ApplicationPropertiesComponent, typeof UpdateApplicationModalComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<EcosystemModule>;
}

declare class PackageGuard {
    private ecosystemService;
    constructor(ecosystemService: EcosystemService);
    canActivate(route: ActivatedRouteSnapshot): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PackageGuard>;
}

export { ActivityLogComponent, AddExternalApplicationComponent, AddMicroserviceComponent, AddPackageComponent, AddWebApplicationComponent, ApplicationListComponent, ApplicationPropertiesComponent, ApplicationPropertiesGuard, DeployApplicationComponent, EcosystemModule, EcosystemTabs, FeatureListComponent, InstallFromPackageComponent, MicroserviceListComponent, PackageDetailsComponent, PackageGuard, PackageVersionsComponent, PackageVersionsPluginsComponent, PackagesListComponent, UpdateApplicationModalComponent };
//# sourceMappingURL=index.d.ts.map