import { IApplication, ApplicationService, TenantService, InventoryService, IManifest, IApplicationVersion, IdReference, IResultList, IFetchResponse, IApplicationVersionDeleteParams, IApplicationBinary, IManagedObject, IResult, ApplicationType, IIdentified, ApplicationAvailability } from '@c8y/client';
import * as i1 from '@c8y/ngx-components';
import { ApplicationPlugin, PropertiesListItem, PackageType, ModalService, AlertService, HumanizeAppNamePipe, AppStateService, ZipService, WizardModalService, PluginsService, GainsightService, WizardComponent, C8yStepper, FilterInputComponent } from '@c8y/ngx-components';
import { UnaryFunction, Observable, BehaviorSubject } from 'rxjs';
import * as i0 from '@angular/core';
import { EventEmitter, OnInit, OnChanges, SimpleChanges, PipeTransform } from '@angular/core';
import * as i5 from '@angular/forms';
import { FormGroup, FormBuilder, ControlValueAccessor, FormControl } from '@angular/forms';
import { TranslateService } from '@ngx-translate/core';
import { SupportedIconsSuggestions } from '@c8y/ngx-components/icon-selector/icons';
import { Router, ActivatedRoute } from '@angular/router';
import { BsModalRef } from 'ngx-bootstrap/modal';
import * as i2 from 'ngx-bootstrap/dropdown';
import * as i3 from 'ngx-bootstrap/tooltip';
import * as i4 from '@angular/cdk/a11y';
import * as i6 from 'ngx-bootstrap/popover';
import * as i7 from '@c8y/ngx-components/icon-selector';

/** Wizard types  */
declare enum EcosystemWizards {
    APPLICATION_UPLOAD = "ecosystemApplicationUpload",
    MICROSERVICE_UPLOAD = "ecosystemMicroserviceUpload",
    PACKAGE_UPLOAD = "ecosystemPackageUpload",
    BLUEPRINT_DEPLOYMENT = "ecosystemBlueprintDeployment",
    LICENSE_CONFIRM = "ecosystemLicenseConfirm",
    ARCHIVED_CONFIRM = "ecosystemArchivedConfirm"
}
declare enum ERROR_TYPE {
    TYPE_VALIDATION = "TYPE_VALIDATION",
    ALREADY_SUBSCRIBED = "ALREADY_SUBSCRIBED",
    ALREADY_EXIST = "ALREADY_EXIST",
    INTERNAL_ERROR = "INTERNAL_ERROR",
    NO_MANIFEST_FILE = "NO_MANIFEST_FILE",
    INVALID_PACKAGE = "INVALID_PACKAGE",
    INVALID_APPLICATION = "INVALID_APPLICATION",
    MICROSERVICE_NAME_TOO_LONG = "MICROSERVICE_NAME_TOO_LONG",
    APPLICATION_CREATION_FAILED = "APPLICATION_CREATION_FAILED",
    KEY_OR_CONTEXT_PATH_MISMATCH = "KEY_OR_CONTEXT_PATH_MISMATCH",
    VERSION_NOT_FOUND = "VERSION_NOT_FOUND"
}
type LicensedApplicationPlugin = Pick<ApplicationPlugin, 'type' | 'license' | 'name' | 'version' | 'contextPath'>;
declare const PRODUCT_EXPERIENCE_ECOSYSTEM: {
    readonly APPLICATIONS: {
        readonly EVENTS: {
            readonly AVAILABILITY: "availability";
            readonly APPLICATION_CARD: "applicationCard";
            readonly APPLICATION_PROPERTIES: "applicationProperties";
            readonly DEPLOY_APPLICATION: "deployApplication";
            readonly DUPLICATE_APPLICATION: "duplicateApplication";
            readonly INSTALLED_PLUGINS: "installedPlugins";
            readonly PACKAGE_PLUGINS: "packagePlugins";
            readonly PACKAGE_VERSIONS: "packageVersions";
            readonly FILTER_LIST: "filterList";
        };
        readonly COMPONENTS: {
            readonly APPLICATION_CARD: "application-card";
            readonly APPLICATION_PLUGINS: "application-plugins";
            readonly APPLICATION_PROPERTIES: "application-properties";
            readonly DEPLOY_APPLICATION: "deploy-application";
            readonly DUPLICATE_APPLICATION_PROPERTIES: "duplicate-application-properties";
            readonly PLUGIN_LIST: "plugin-list";
            readonly PACKAGE_VERSIONS: "package-versions-list";
            readonly UPDATE_PLUGIN_OF_APP: "update-plugin-of-app";
            readonly LIST_FILTERS: "list-filters";
            readonly PACKAGE_DETAILS: "package-details";
        };
        readonly ACTIONS: {
            readonly AVAILABILITY_CHANGE: "availabilityChange";
            readonly CANCEL: "cancel";
            readonly CLONE: "clone";
            readonly CHANGE_PLUGIN_VERSION: "changePluginVersion";
            readonly DELETE: "delete";
            readonly DOWNLOAD: "download";
            readonly DEPLOY_APPLICATION: "deployApplication";
            readonly EDIT: "edit";
            readonly INSTALL_PLUGIN: "installPlugin";
            readonly INSTALL_PLUGINS: "installPlugins";
            readonly UNINSTALL_PLUGIN: "uninstallPlugin";
            readonly SELECT_VERSION: "selectVersion";
            readonly SET_AS_LATEST: "setAsLatest";
            readonly UPDATE_AVAILABLE: "updateAvailable";
            readonly UPLOAD: "upload";
            readonly SET_FILTER_TERM: "setFilterTerm";
            readonly SET_PREDEFINED_FILTERS: "setPredefinedFilters";
            readonly RESET_FILTER: "resetFilter";
            readonly INSTALL_PLUGINS_INITIATED: "installPluginsInitiated";
            readonly DEPLOY_APPLICATION_INITIATED: "deployApplicationInitiated";
        };
        readonly RESULTS: {
            readonly DEPLOYED: "deployed";
            readonly DUPLICATED: "duplicated";
            readonly PLUGIN_INSTALLED: "pluginInstalled";
            readonly PLUGIN_REMOVED: "pluginRemoved";
            readonly PLUGIN_VERSION_CHANGED: "pluginVersionChanged";
            readonly SERVER_FAILURE: "serverFailure";
            readonly SUCCESS: "success";
        };
    };
};

declare class EcosystemError extends Error {
    type: ERROR_TYPE;
    constructor(type: ERROR_TYPE);
}

declare const ERROR_MESSAGES: {
    ALREADY_EXIST: "Could not deploy the application, as an application with the same name`KEEP_ORIGINAL`, context-path`KEEP_ORIGINAL` or key`KEEP_ORIGINAL` exists already.";
    TYPE_VALIDATION: "Wrong file format. Expected a *.zip file with a valid manifest.";
    ALREADY_SUBSCRIBED: "Could not subscribe to the microservice because another application with the same context path is already subscribed.";
    NO_MANIFEST_FILE: "Could not find a manifest.";
    INVALID_PACKAGE: "You have not uploaded a valid package.";
    INVALID_APPLICATION: "You have not uploaded a valid application.";
    INTERNAL_ERROR: "An internal error occurred, try to upload again.";
    MICROSERVICE_NAME_TOO_LONG: "Microservice name \"{{ name }}\" must not be longer than {{ maxChars }} characters.";
    APPLICATION_CREATION_FAILED: "Application creation failed.";
    KEY_OR_CONTEXT_PATH_MISMATCH: "The \"contextPath`KEEP_ORIGINAL`\" or \"key`KEEP_ORIGINAL`\" of the uploaded archive do not match with the existing application.";
    VERSION_NOT_FOUND: "The selected version was not found on the server.";
};
declare const APP_STATE: {
    SUBSCRIBED: {
        label: "Subscribed`application`";
        class: string;
        tooltip: "Provided by parent tenant.";
    };
    CUSTOM: {
        label: "Custom`application`";
        class: string;
        tooltip: "Manually uploaded to the platform.";
    };
    EXTERNAL: {
        label: "External`application`";
        class: string;
        tooltip: "Application hosted outside of the platform.";
    };
    UNPACKED: {
        label: "Unpacked`application`";
        class: string;
        tooltip: "Deployed from a package available under \"Packages\".";
    };
    PACKAGE_BLUEPRINT: {
        label: "Blueprint";
        class: string;
        tooltip: "Contains an application and may include plugins.";
    };
    PACKAGE_PLUGIN: {
        label: "Plugins";
        class: string;
        tooltip: "Contains only plugins.";
    };
    PACKAGE_UNKNOWN: {
        label: "Unknown`package-type`";
        class: string;
        tooltip: "Package contents could not be determined.";
    };
};
type ApplicationState = (typeof APP_STATE)[keyof typeof APP_STATE];
declare const PACKAGE_TYPE_LABELS: {
    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.";
    };
};
declare const packageProperties: PropertiesListItem[];

type FilterableAppOrPlugin = (IApplication | ApplicationPlugin) & {
    filterProps?: AppFilterProps;
};
type FilterPipe = UnaryFunction<Observable<FilterableAppOrPlugin[]>, Observable<FilterableAppOrPlugin[]>>;
type PackageFilters = {
    type: {
        [PackageType.OFFICIAL]?: boolean;
        [PackageType.COMMUNITY]?: boolean;
    };
    availability: {
        [APP_STATE.SUBSCRIBED.label]?: boolean;
        [APP_STATE.UNPACKED.label]?: boolean;
        [APP_STATE.EXTERNAL.label]?: boolean;
        [APP_STATE.CUSTOM.label]?: boolean;
    };
    content: {
        [APP_STATE.PACKAGE_BLUEPRINT.label]?: boolean;
        [APP_STATE.PACKAGE_PLUGIN.label]?: boolean;
    };
    custom: {
        [key: string]: boolean;
    };
};
type AppFilterProps = {
    type: PackageType;
    availability: ApplicationState['label'];
    content: ApplicationState['label'];
};
declare const defaultPackageTypes: (keyof PackageFilters['type'])[];
declare const defaultPackageAvailabilities: (keyof PackageFilters['availability'])[];
declare const defaultPackageContents: (keyof PackageFilters['content'])[];

declare class EcosystemService {
    private modal;
    private alertService;
    private humanizeAppName;
    private translateService;
    private applicationService;
    private appStateService;
    private zipService;
    private tenantService;
    private inventoryService;
    private wizardModalService;
    private pluginService;
    appDeleted: EventEmitter<IApplication>;
    progress: BehaviorSubject<number>;
    private appsGroupedByContextPath$;
    private xhr;
    constructor(modal: ModalService, alertService: AlertService, humanizeAppName: HumanizeAppNamePipe, translateService: TranslateService, applicationService: ApplicationService, appStateService: AppStateService, zipService: ZipService, tenantService: TenantService, inventoryService: InventoryService, wizardModalService: WizardModalService, pluginService: PluginsService);
    getUniqueAppConfig(srcApp: Pick<IApplication, 'name' | 'key' | 'contextPath'> & Partial<IApplication>, existingApps: IApplication[]): Pick<IApplication, 'name' | 'key' | 'contextPath'>;
    /**
     * Verify versions compatibility for blueprints. If a blueprint version
     * is not compatible, a warning is shown.
     *
     * @param blueprint The blueprint to install.
     * @returns true if the installation can continue or false if it should be aborted.
     */
    verifyBlueprintVersionsCompatibility(blueprint: Partial<IManifest>): Promise<boolean>;
    /**
     * Verify versions compatibility for plugins. In case a version does not exist in the
     * versioningMatrix we don't do anything due to backward compatibility. If a plugin version
     * is not compatible, a warning is shown.
     *
     * @param pluginsToInstall The list of plugins to install.
     * @returns true if the installation can continue or false if it should be aborted.
     */
    verifyPluginVersionsCompatibility(pluginsToInstall: ApplicationPlugin[], app: IApplication): Promise<boolean>;
    /**
     * Community plugins need to verify the license agreement. If a package is a community
     * package, the license is shown.
     *
     * @param pluginsToInstall The list of plugins to install.
     * @returns true if the installation can continue.
     */
    verifyLicenses(pluginsToInstall: Array<LicensedApplicationPlugin>): Promise<boolean>;
    /**
     * If the plugin is archived, a warning should be shown.
     *
     * @param pluginsToInstall The list of plugins to install.
     * @returns true if the installation can continue.
     */
    verifyArchived(pluginsToInstall: Array<LicensedApplicationPlugin>): Promise<boolean>;
    /**
     * @description
     * Compares currently deployed application version with application version tagged as "latest"
     *
     * @param {string} currentApplicationVersion Deployed application version
     * @param {object} latestApp Latest application version object
     *
     * @returns {boolean} Returns true if latest version is greater than current, otherwise false
     */
    shouldUpgradePackage(currentApplicationVersion: string, latestApp: IApplicationVersion): boolean;
    /**
     * @description
     * Gets an object that contains searched tag
     *
     * @param {array} applicationVersions Array with all available versions
     * @param {string} tagName Searched tag
     *
     * @returns {object} Returns an object with searched tag
     */
    getApplicationVersionObjectByTag(applicationVersions: IApplicationVersion[], tagName: string): IApplicationVersion;
    getApplication(appId: IdReference): Promise<IApplication>;
    getApplications(customFilter?: any): Promise<IResultList<IApplication>>;
    getMicroservices(): Promise<IApplication[]>;
    getWebApplications(customFilter?: any): Promise<IApplication[]>;
    getFeatureApplications(customFilter?: any): Promise<IApplication[]>;
    getPackageApplications(customFilter?: any): Promise<IApplication[]>;
    getHostedAndPackageApplications(customFilter?: any): Promise<IApplication[]>;
    getApplicationsFiltered(customFilter?: any, filterCallback?: (app: IApplication) => boolean): Promise<IApplication[]>;
    isMicroserviceHostingAllowed(): Promise<boolean>;
    canOpenAppInBrowser(app: IApplication): boolean;
    openApp(app: any): void;
    canDeleteApp(app: IApplication): Promise<boolean>;
    isOwner(app: IApplication): boolean;
    isFeature(app: IApplication): boolean;
    isMicroservice(app: IApplication): boolean;
    isExternal(app: IApplication): boolean;
    isPackage(app: IApplication): boolean;
    isPlugin(app: IApplication): boolean;
    cancelAppCreation(app: IApplication): void;
    updateUploadProgress(event: any): void;
    setAppActiveVersion(app: IApplication, activeVersionId: string): Promise<IApplication>;
    setPackageVersionTag(app: IApplication, version: string, tags: string[]): Promise<{
        res: IFetchResponse;
        data: any;
    }>;
    deletePackageVersion(app: IApplication, params: IApplicationVersionDeleteParams): Promise<{
        res: IFetchResponse;
        data: any;
    }>;
    getHumanizedAppName(app: IApplication): Promise<string>;
    createConfig(app: IApplication, formGroupValue: FormGroup): Partial<IApplication>;
    listArchives(appId: string | number | IApplication): Promise<IApplicationBinary[]>;
    deleteArchive(archive: IApplicationBinary, app: IApplication): Promise<void>;
    getArchiveManagedObject(binaryId: string): Promise<IManagedObject>;
    downloadArchive(app: IApplication, archive: Pick<IApplicationBinary, 'name' | 'id'>): Promise<void>;
    updateApp(app: IApplication, deleteOnFailure?: boolean): Promise<IResult<IApplication>>;
    deleteApp(app: IApplication, silent?: boolean): Promise<void>;
    checkIfSubscribed(app: IApplication): Promise<boolean>;
    subscribeApp(app: IApplication): Promise<void>;
    unsubscribeApp(app: IApplication): Promise<void>;
    isValidAppType(archive: File, appType: ApplicationType): Promise<boolean>;
    uploadArchiveToApp(archive: File, app: IApplication, isNewVersion?: boolean, queryParams?: Record<string, string | boolean>): Promise<IApplication>;
    validateArchiveToAppCompatibility(archive: File, app: IApplication): Promise<void>;
    getCumulocityJson(archive: File): Promise<IManifest | null>;
    createAppForArchive(archive: any, isPackageTypeArchive?: boolean): Promise<IApplication>;
    reactivateArchive(app: IApplication): Promise<void>;
    removeOldestArchive(app: IApplication, archives: IApplicationBinary[]): Promise<void>;
    deployApp(selectedPackage: IApplication, formGroupValue: any, model: any): Promise<IApplication>;
    fallbackToClone(application: IApplication, selectedPackage: IApplication, requestedVersion?: string): Promise<boolean>;
    uploadBinaryFromOtherPackage(selectedPackage: IApplication, applicationToUploadBinaryTo: IApplication, binaryId: string, requestedVersion?: string, useBinariesFrom?: IApplication): Promise<void>;
    getAppState(app: IApplication): ApplicationState;
    getPackageContentState(app: IApplication): ApplicationState;
    isPackageBlueprint(app: IApplication): boolean;
    isPluginsPackage(app: IApplication): boolean;
    isUnpacked(app: IApplication): boolean;
    hasExports(app: IApplication): boolean;
    isApplication(app: IApplication): boolean;
    isCustomMicroservice(app: IApplication): boolean;
    getBinary(app: IApplication, archive: IApplicationBinary | IIdentified): Promise<ArrayBuffer>;
    isOverwrittenByCustomApp(app: IApplication): Promise<boolean>;
    hasSubscribedAppParent(app: IApplication): Promise<boolean>;
    /**
     * @deprecated
     */
    setAvailabilityToPrivateIfNotSetAlready(app: IApplication): IApplication;
    /**
     * Shows an error dialog.
     * @param error Either a server error or an internal [[EcosystemError]].
     */
    alertError(error: Error | EcosystemError): void;
    validatePackageKeyAndContextPath(manifest: IManifest, app: IApplication): Promise<void>;
    filterContainString(name: string, filterTerm: string): boolean;
    updateAppManifest(application: IApplication, selectedPackage: IApplication, requestedVersion?: string): Promise<{
        res: IFetchResponse;
        data: any;
    }>;
    /**
     * Creates object containing properties for filtering applications on lists.
     *
     * @param {object} app Application to create filter properties from.
     * @returns {object} Properties to filter by applications list.
     */
    getAppFilterProps(app: IApplication): AppFilterProps;
    private checkIfAppNameKeyPathExists;
    private showModal;
    private getPlatformVersion;
    private getAppKey;
    private getContextPath;
    private removeForbiddenCharacters;
    private isCurrentApp;
    private getCumulocityJson$;
    private getAppType;
    private getBaseNameFromArchiveOrAppModel;
    private removeAppProperties;
    private getUploadOverrides;
    private removeVersionFromName;
    private isNameLengthExceeded;
    static ɵfac: i0.ɵɵFactoryDeclaration<EcosystemService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EcosystemService>;
}

declare class PackageAvailabilityService {
    private appState;
    private alert;
    private modal;
    private application;
    private gainsightService;
    private translateService;
    CURRENT_LOCATION: string;
    availabilities: ({
        label: "Private`package availability`";
        value: ApplicationAvailability;
    } | {
        label: "Market`package availability`";
        value: ApplicationAvailability;
    } | {
        label: "Shared`package availability`";
        value: ApplicationAvailability;
    })[];
    constructor(appState: AppStateService, alert: AlertService, modal: ModalService, application: ApplicationService, gainsightService: GainsightService, translateService: TranslateService);
    askIfAvailabilityShouldBeSetTo(applicationPackage: IApplication, availability: ApplicationAvailability): Promise<IApplication>;
    setAvailability(applicationPackage: IApplication, availability: ApplicationAvailability): Promise<IApplication>;
    private getConfirmationBody;
    private openAvailabilityModal;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageAvailabilityService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PackageAvailabilityService>;
}

declare class AddApplicationComponent {
    private ecosystemService;
    private alertService;
    private applicationService;
    private wizardComponent;
    private translateService;
    private packageAvailability;
    headerText: string;
    headerIcon: SupportedIconsSuggestions;
    successText: string;
    createApplicationHandler: any;
    uploadApplicationHandler: any;
    canGoBack: boolean;
    applicationType: 'application' | 'package';
    dropAreaComponent: any;
    isLoading: boolean;
    isAppCreated: boolean;
    createdApp: IApplication;
    canOpenInBrowser: boolean;
    errorMessage: string;
    selectedAvailability: ApplicationAvailability;
    availabilityHelpPopoverText: "\n      <p class=\"m-b-8\"><b>Shared</b> availability will make the package available to all subtenants without explicitly subscribing the package.</p>\n      <p class=\"m-b-8\"><b>Market</b> availability will make the package available to your own tenant and needs to be subscribed to subtenants individually.</p>\n      <p class=\"m-b-8\"><b>Private</b> availability will make the package only available to your own tenant.</p>\n  ";
    private uploadCanceled;
    constructor(ecosystemService: EcosystemService, alertService: AlertService, applicationService: ApplicationService, wizardComponent: WizardComponent, translateService: TranslateService, packageAvailability: PackageAvailabilityService);
    get progress(): BehaviorSubject<number>;
    onFileDroppedEvent(event: any): void;
    onFile(file: File): Promise<void>;
    getHref(app: IApplication): string;
    cancel(): void;
    done(): void;
    back(): void;
    private cancelFileUpload;
    static ɵfac: i0.ɵɵFactoryDeclaration<AddApplicationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AddApplicationComponent, "c8y-add-application", never, { "headerText": { "alias": "headerText"; "required": false; }; "headerIcon": { "alias": "headerIcon"; "required": false; }; "successText": { "alias": "successText"; "required": false; }; "createApplicationHandler": { "alias": "createApplicationHandler"; "required": false; }; "uploadApplicationHandler": { "alias": "uploadApplicationHandler"; "required": false; }; "canGoBack": { "alias": "canGoBack"; "required": false; }; "applicationType": { "alias": "applicationType"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ApplicationCardComponent implements OnInit {
    private applicationService;
    private ecosystemService;
    private alertService;
    private router;
    private wizardModalService;
    private alert;
    private pluginService;
    private gainsightService;
    CURRENT_LOCATION: string;
    app: IApplication;
    canEdit: boolean;
    onAppDeleted: EventEmitter<void>;
    onAppCloned: EventEmitter<void>;
    appState: ApplicationState;
    packageContentState: ApplicationState;
    packageType: PackageType;
    canOpenInBrowser: boolean;
    disableOpenInBrowser: boolean;
    canDelete: boolean;
    isPackage: boolean;
    isPlugin: boolean;
    isFeature: boolean;
    isExternal: boolean;
    isMicroservice: boolean;
    canClone: boolean;
    isUnpacked: boolean;
    shouldUpgradePackage: boolean;
    blueprintApplicationVersion: IApplicationVersion[];
    latestApplicationVersion: IApplicationVersion;
    isShowVersion: boolean;
    isOwnedByManagementTenant: boolean;
    get openButtonTitle(): "Open" | "This application is overridden.";
    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 UNPACKED_LABEL: "Unpacked`application`";
    readonly CANNOT_DELETE_HINT: "Subscribed or current applications can't be deleted. Delete the application on the parent tenant or unsubscribe it from the current.";
    readonly PACKAGE_CONTENT_UNDETERMINED_LABEL: "Package contents could not be determined.";
    constructor(applicationService: ApplicationService, ecosystemService: EcosystemService, alertService: AlertService, router: Router, wizardModalService: WizardModalService, alert: AlertService, pluginService: PluginsService, gainsightService: GainsightService);
    ngOnInit(): Promise<void>;
    shouldShowVersion(): boolean;
    detail(): void;
    openApp(): void;
    delete(): Promise<void>;
    clone(): Promise<void>;
    private applicationUpdateCheck;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationCardComponent, "c8y-application-card", never, { "app": { "alias": "app"; "required": false; }; "canEdit": { "alias": "canEdit"; "required": false; }; }, { "onAppDeleted": "onAppDeleted"; "onAppCloned": "onAppCloned"; }, never, never, true, never>;
}

declare class ApplicationPropertiesFormComponent implements OnChanges {
    private formBuilder;
    formGroup: FormGroup;
    application: IApplication;
    disabled: boolean;
    constructor(formBuilder: FormBuilder);
    ngOnChanges(changes: SimpleChanges): void;
    private initForm;
    private setForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationPropertiesFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ApplicationPropertiesFormComponent, "c8y-application-properties-form", never, { "application": { "alias": "application"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DuplicateApplicationListComponent {
    ecosystemService: EcosystemService;
    private wizardComponent;
    stepper: C8yStepper;
    existingApps: IApplication[];
    onSelectedApp: EventEmitter<IApplication>;
    appState: ApplicationState;
    constructor(ecosystemService: EcosystemService, wizardComponent: WizardComponent);
    select(selectedApp: IApplication): void;
    cancel(): void;
    back(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DuplicateApplicationListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DuplicateApplicationListComponent, "c8y-duplicate-application-list", never, { "stepper": { "alias": "stepper"; "required": false; }; "existingApps": { "alias": "existingApps"; "required": false; }; }, { "onSelectedApp": "onSelectedApp"; }, never, never, true, never>;
}

declare class DuplicateApplicationPropertiesComponent {
    private bsModalRef;
    private ecosystemService;
    private applicationService;
    private gainsightService;
    CURRENT_LOCATION: string;
    stepper: C8yStepper;
    existingApps: IApplication[];
    selectedApp: BehaviorSubject<IApplication>;
    isFirstStep: boolean;
    duplicatedApp: EventEmitter<IApplication>;
    applicationPropertiesForm: ApplicationPropertiesFormComponent;
    newAppConfig: IApplication;
    disableForm: boolean;
    isSubscribedApp$: Observable<boolean>;
    inProgress: boolean;
    constructor(bsModalRef: BsModalRef, ecosystemService: EcosystemService, applicationService: ApplicationService, gainsightService: GainsightService);
    ngOnInit(): void;
    duplicateApp(): Promise<void>;
    cancel(): void;
    back(): void;
    getAppConfig(): void;
    private updateApp;
    private updateManifest;
    private getAppManifest;
    static ɵfac: i0.ɵɵFactoryDeclaration<DuplicateApplicationPropertiesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DuplicateApplicationPropertiesComponent, "c8y-duplicate-application-properties", never, { "stepper": { "alias": "stepper"; "required": false; }; "existingApps": { "alias": "existingApps"; "required": false; }; "selectedApp": { "alias": "selectedApp"; "required": false; }; "isFirstStep": { "alias": "isFirstStep"; "required": false; }; }, { "duplicatedApp": "duplicatedApp"; }, never, never, true, never>;
}

declare class DuplicateApplicationComponent implements OnInit {
    private ecosystemService;
    private applicationService;
    private wizardComponent;
    stepper: C8yStepper;
    duplicatedApp: IApplication;
    selectedApp: BehaviorSubject<IApplication>;
    existingApps: IApplication[];
    directlyMoveToSecondStep: boolean;
    noBackButton: boolean;
    constructor(ecosystemService: EcosystemService, applicationService: ApplicationService, wizardComponent: WizardComponent);
    ngOnInit(): Promise<void>;
    onSelectedApp(app: IApplication): void;
    getHref(app: IApplication): string;
    done(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DuplicateApplicationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DuplicateApplicationComponent, "c8y-duplicate-application", never, {}, {}, never, never, true, never>;
}

declare class PackageVersionSelectComponent implements OnChanges, ControlValueAccessor {
    private applicationService;
    private pluginsService;
    label: "Use plugin version";
    packageContextPath: string;
    packageId: string | number;
    selectedVersion: IApplicationVersion;
    onInput$: BehaviorSubject<string>;
    versions$: Observable<IResultList<IApplicationVersion>>;
    isDisabled: boolean;
    private packageContextPath$;
    private packageId$;
    private onChange;
    private onTouched;
    constructor(applicationService: ApplicationService, pluginsService: PluginsService);
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    ngOnChanges(changes: SimpleChanges): void;
    getPackageVersions(packageId: string | number): Promise<IResultList<IApplicationVersion>>;
    onVersionSelect(version: IApplicationVersion): void;
    private getPackageIdForContextPath;
    private setInitialValueForInput;
    private filterAppVersions;
    private applyFilterToResultList;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageVersionSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageVersionSelectComponent, "c8y-package-version-select", never, { "label": { "alias": "label"; "required": false; }; "packageContextPath": { "alias": "packageContextPath"; "required": false; }; "packageId": { "alias": "packageId"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * Component to display the change log of a package.
 * It fetches the change log file from the package's repository and displays it.
 * It can fetch the change log for the latest version or a specific version if provided.
 * It can also compare the change log with the previous version if provided and display the difference between the two versions.
 */
declare class PackageChangelogComponent implements OnChanges {
    package: IApplication;
    selectedVersion: string;
    previousVersion: string | null;
    changelog: string;
    baseUrl: string;
    isLoading: boolean;
    private pluginsService;
    ngOnChanges(): Promise<void>;
    private getChangeLog;
    private baseUrlForVersion;
    static ɵfac: i0.ɵɵFactoryDeclaration<PackageChangelogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PackageChangelogComponent, "c8y-contents-changelog", never, { "package": { "alias": "package"; "required": false; }; "selectedVersion": { "alias": "selectedVersion"; "required": false; }; "previousVersion": { "alias": "previousVersion"; "required": false; }; }, {}, never, never, true, never>;
}

declare class UploadArchiveComponent {
    private ecosystemService;
    private alertService;
    application: IApplication;
    uploadNewVersion: boolean;
    preUploadCallback: () => Promise<any>;
    applicationChange: EventEmitter<IApplication>;
    refresh: EventEmitter<any>;
    archives: IApplicationBinary[];
    toActivateVersionId: string;
    last: IApplicationBinary;
    isLoading: boolean;
    fileList: FileList;
    uploadInProgress: boolean;
    canReactivate: boolean;
    constructor(ecosystemService: EcosystemService, alertService: AlertService);
    get uploadProgress(): BehaviorSubject<number>;
    onFileDroppedEvent(event: any): Promise<void>;
    private onFile;
    static ɵfac: i0.ɵɵFactoryDeclaration<UploadArchiveComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UploadArchiveComponent, "c8y-upload-archive", never, { "application": { "alias": "application"; "required": false; }; "uploadNewVersion": { "alias": "uploadNewVersion"; "required": false; }; "preUploadCallback": { "alias": "preUploadCallback"; "required": false; }; }, { "applicationChange": "applicationChange"; "refresh": "refresh"; }, never, never, true, never>;
}

declare class TranslatePackageLabelPipe implements PipeTransform {
    private translate;
    constructor(translate: TranslateService);
    transform(rawPackageLabel: PackageType.OFFICIAL | PackageType.COMMUNITY | PackageType.ARCHIVED | string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TranslatePackageLabelPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TranslatePackageLabelPipe, "translatePackageLabel", true>;
}

declare class ListFiltersComponent implements OnInit {
    private formBuilder;
    private ui;
    private translateService;
    private gainsightService;
    private router;
    private activatedRoute;
    packageTypes: (keyof PackageFilters['type'])[];
    packageAvailabilities: (keyof PackageFilters['availability'])[];
    packageContents: (keyof PackageFilters['content'])[];
    filterPipeChange: EventEmitter<FilterPipe>;
    filterInput: FilterInputComponent;
    formGroup: ReturnType<ListFiltersComponent['initForm']>;
    chips: [string, FormControl][];
    predefinedFiltersVisible: boolean;
    customFilters: Map<string, (app: FilterableAppOrPlugin, enabled: boolean) => boolean>;
    currentFilterTerm: string;
    private currentLang;
    private data;
    private currentFiltersState;
    private CURRENT_LOCATION;
    private destroy$;
    constructor(formBuilder: FormBuilder, ui: AppStateService, translateService: TranslateService, gainsightService: GainsightService, router: Router, activatedRoute: ActivatedRoute);
    ngOnInit(): void;
    setFilterTerm(filterTerm: string): void;
    applyPredefinedFilters(): void;
    reset(): void;
    resetAllFilters(): void;
    toggleDropdown(isOpen: boolean): void;
    deselectChip(chip: [string, FormControl]): void;
    ngOnDestroy(): void;
    subscribeToQueryParams(): void;
    private setQueryParams;
    private parseQueryParams;
    private simplifyFilterObject;
    private initForm;
    private setPipe;
    private filterContainString;
    private appMatchesByPredefinedProperty;
    private setChips;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListFiltersComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListFiltersComponent, "c8y-list-filters", never, { "packageTypes": { "alias": "packageTypes"; "required": false; }; "packageAvailabilities": { "alias": "packageAvailabilities"; "required": false; }; "packageContents": { "alias": "packageContents"; "required": false; }; }, { "filterPipeChange": "filterPipeChange"; }, never, ["*"], true, never>;
}

declare class ArchivedFilterComponent {
    filterComponent: ListFiltersComponent;
    archivedFormControl: FormControl;
    private readonly filterLabel;
    constructor(filterComponent: ListFiltersComponent);
    static ɵfac: i0.ɵɵFactoryDeclaration<ArchivedFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ArchivedFilterComponent, "c8y-archived-filter", never, {}, {}, never, never, true, never>;
}

declare class SharedEcosystemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SharedEcosystemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedEcosystemModule, never, [typeof i1.CoreModule, typeof i2.BsDropdownModule, typeof i3.TooltipModule, typeof i4.A11yModule, typeof i5.FormsModule, typeof i6.PopoverModule, typeof i5.ReactiveFormsModule, typeof i7.IconSelectorModule, typeof PackageChangelogComponent, typeof AddApplicationComponent, typeof ApplicationPropertiesFormComponent, typeof UploadArchiveComponent, typeof ApplicationCardComponent, typeof DuplicateApplicationListComponent, typeof DuplicateApplicationPropertiesComponent, typeof DuplicateApplicationComponent, typeof PackageVersionSelectComponent, typeof TranslatePackageLabelPipe, typeof ListFiltersComponent, typeof ArchivedFilterComponent], [typeof AddApplicationComponent, typeof ApplicationPropertiesFormComponent, typeof UploadArchiveComponent, typeof ApplicationCardComponent, typeof DuplicateApplicationListComponent, typeof DuplicateApplicationPropertiesComponent, typeof DuplicateApplicationComponent, typeof PackageVersionSelectComponent, typeof TranslatePackageLabelPipe, typeof ListFiltersComponent, typeof ArchivedFilterComponent, typeof PackageChangelogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SharedEcosystemModule>;
}

export { APP_STATE, AddApplicationComponent, ApplicationCardComponent, ApplicationPropertiesFormComponent, ArchivedFilterComponent, DuplicateApplicationComponent, DuplicateApplicationListComponent, DuplicateApplicationPropertiesComponent, ERROR_MESSAGES, ERROR_TYPE, EcosystemService, EcosystemWizards, ListFiltersComponent, PACKAGE_TYPE_LABELS, PRODUCT_EXPERIENCE_ECOSYSTEM, PackageAvailabilityService, PackageChangelogComponent, PackageVersionSelectComponent, SharedEcosystemModule, TranslatePackageLabelPipe, UploadArchiveComponent, defaultPackageAvailabilities, defaultPackageContents, defaultPackageTypes, packageProperties };
export type { AppFilterProps, ApplicationState, FilterPipe, FilterableAppOrPlugin, LicensedApplicationPlugin, PackageFilters };
//# sourceMappingURL=index.d.ts.map
