@c8y/ngx-components/cockpit-config/index.d.ts

Angular modules for Cumulocity IoT applications

import * as i1 from '@c8y/ngx-components';
import { NavigatorNodeFactory, NavigatorNode, Permissions, AppStateService, NavigatorService, TabsService, SearchService, OptionsService, AlertService, C8yStepper, SetupComponent } from '@c8y/ngx-components';
import { EcosystemService } from '@c8y/ngx-components/ecosystem/shared';
import * as i0 from '@angular/core';
import { OnInit, EventEmitter } from '@angular/core';
import { InventoryService, ApplicationService, IApplication } from '@c8y/client';
import * as i2 from '@c8y/ngx-components/assets-navigator';
import { AssetNavigatorConfig, AssetNodeService } from '@c8y/ngx-components/assets-navigator';
import * as i3 from 'ngx-bootstrap/popover';
import * as i4 from 'ngx-bootstrap/tooltip';
import * as i5 from '@c8y/ngx-components/ecosystem';
import * as i6 from '@c8y/ngx-components/icon-selector';
import { CdkStep } from '@angular/cdk/stepper';
import { Observable } from 'rxjs';

declare class CockpitConfigGuard implements NavigatorNodeFactory {
    private permissions;
    private appState;
    private ecosystemService;
    protected readonly configNode: NavigatorNode;
    constructor(permissions: Permissions, appState: AppStateService, ecosystemService: EcosystemService);
    get(): NavigatorNode;
    canActivate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitConfigGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CockpitConfigGuard>;
}

declare const DEFAULT_HOME_DASHBOARD_NAME = "home-cockpit1";
declare const USER_HOME_DASHBOARD_NAME = "home-cockpit-user";
interface CockpitConfig {
    rootNodes: CockpitConfigRootNode[];
    features: {
        alarms: boolean;
        dataExplorer: boolean;
        groups: boolean;
        reports: boolean;
        exports: boolean;
        dataPointLibrary: boolean;
        globalSmartRules: boolean;
        smartRules: boolean;
        subassets: boolean;
        search: boolean;
        dashboardManager: boolean;
        [key: string]: boolean;
    };
    hideNavigator: boolean;
    homeDashboardName: string;
    userSpecificHomeDashboard: boolean;
    icon: {
        class: string;
    };
    appTitle?: string;
    htmlWidgetDisableSanitization?: boolean;
    htmlWidgetDefaultToAdvancedMode?: boolean;
}
declare const DEFAULT_CONFIG: CockpitConfig;
interface CockpitConfigRootNode {
    id: string;
    name: string;
    hideDevices?: boolean;
}
declare enum HomeDashboardType {
    /**
     * Shared by all Cockpit apps
     */
    DEFAULT = 0,
    /**
     * Only for the current Cockpit.
     */
    APP = 1,
    /**
     * Only for the current user.
     */
    USER = 2
}
declare const COCKPIT_CONFIG_PATH = "cockpit-application-configuration";

declare class CockpitConfigService {
    private navigatorService;
    private tabsService;
    private searchService;
    private assetNodeService;
    private inventoryService;
    private appState;
    private applicationService;
    private optionsService;
    private permissions;
    moduleConfig: AssetNavigatorConfig;
    currentConfig: CockpitConfig;
    nodes: NavigatorNode[];
    private navigationFactory;
    private readonly DEFAULT_NODE_PRIORITY;
    get excludedFeatureKeys(): string[];
    constructor(navigatorService: NavigatorService, tabsService: TabsService, searchService: SearchService, assetNodeService: AssetNodeService, inventoryService: InventoryService, appState: AppStateService, applicationService: ApplicationService, optionsService: OptionsService, permissions: Permissions, moduleConfig: AssetNavigatorConfig);
    init(): void;
    /**
     * Save and apply new cockpit configuration
     * @param config - New cockpit configuration
     */
    saveConfig(config: CockpitConfig): Promise<void>;
    /**
     * Update current application using the provided configuration
     * @param config - Cockpit configuration
     */
    updateApplication(config: CockpitConfig): Promise<void>;
    refresh(): void;
    setRootNodes(): Promise<void>;
    getAppDashboardName(): string;
    private storeApplicationConfig;
    private addNodesToFactories;
    private registerFilterForFeatures;
    private setHiddenAttrLock;
    private filterTabs;
    private filterNavigatorNode;
    private hideChildrenNodesThatAreDisabled;
    private showAllChildrenNodes;
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitConfigService, [null, null, null, null, null, null, null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CockpitConfigService>;
}

declare class CockpitConfigurationComponent implements OnInit {
    private cockpitConfigService;
    private alertService;
    private appState;
    /**
     * The currently used configuration.
     */
    config: CockpitConfig;
    rootNodeDisabled: boolean;
    constructor(cockpitConfigService: CockpitConfigService, alertService: AlertService, appState: AppStateService);
    /**
     * @ignore
     */
    ngOnInit(): void;
    /**
     * Stores the configuration and shows a success message.
     */
    save(): Promise<void>;
    /**
     * @ignore
     */
    iconSelectionChange(icon: string): void;
    /**
     * Updates the features to directly reflect the results of the change.
     */
    updateFeatures(): void;
    /**
     * Updates the root nodes to directly reflect the results of the change.
     */
    updateRootNodes(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CockpitConfigurationComponent, "c8y-cockpit-configuration", never, {}, {}, never, never, true, never>;
}

declare abstract class CockpitSetupStep {
    stepper: C8yStepper;
    protected step: CdkStep;
    protected setup: SetupComponent;
    protected appState: AppStateService;
    protected alert: AlertService;
    protected applicationService: ApplicationService;
    protected cockpitConfigService: CockpitConfigService;
    config: CockpitConfig;
    pending: boolean;
    constructor(stepper: C8yStepper, step: CdkStep, setup: SetupComponent, appState: AppStateService, alert: AlertService, applicationService: ApplicationService, cockpitConfigService: CockpitConfigService);
    next(): Promise<void>;
    back(): void;
}

declare class CockpitSetupStep1Component extends CockpitSetupStep {
    stepper: C8yStepper;
    protected step: CdkStep;
    protected setup: SetupComponent;
    protected appState: AppStateService;
    protected alert: AlertService;
    protected appService: ApplicationService;
    protected cockpitConfigService: CockpitConfigService;
    app$: Observable<IApplication>;
    constructor(stepper: C8yStepper, step: CdkStep, setup: SetupComponent, appState: AppStateService, alert: AlertService, appService: ApplicationService, cockpitConfigService: CockpitConfigService);
    iconSelectionChange(icon: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitSetupStep1Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CockpitSetupStep1Component, "c8y-cockpit-setup-step1", never, {}, {}, never, never, true, never>;
}

declare class CockpitSetupStep2Component extends CockpitSetupStep {
    stepper: C8yStepper;
    protected step: CdkStep;
    protected setup: SetupComponent;
    protected appState: AppStateService;
    protected alert: AlertService;
    protected appService: ApplicationService;
    protected cockpitConfigService: CockpitConfigService;
    constructor(stepper: C8yStepper, step: CdkStep, setup: SetupComponent, appState: AppStateService, alert: AlertService, appService: ApplicationService, cockpitConfigService: CockpitConfigService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitSetupStep2Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CockpitSetupStep2Component, "c8y-cockpit-setup-step2", never, {}, {}, never, never, true, never>;
}

declare class CockpitSetupStep3Component extends CockpitSetupStep {
    stepper: C8yStepper;
    protected step: CdkStep;
    protected setup: SetupComponent;
    protected appState: AppStateService;
    protected alert: AlertService;
    protected appService: ApplicationService;
    protected cockpitConfigService: CockpitConfigService;
    constructor(stepper: C8yStepper, step: CdkStep, setup: SetupComponent, appState: AppStateService, alert: AlertService, appService: ApplicationService, cockpitConfigService: CockpitConfigService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitSetupStep3Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CockpitSetupStep3Component, "c8y-cockpit-setup-step3", never, {}, {}, never, never, true, never>;
}

declare class CockpitSetupStep4Component extends CockpitSetupStep {
    stepper: C8yStepper;
    protected step: CdkStep;
    protected setup: SetupComponent;
    protected appState: AppStateService;
    protected alert: AlertService;
    protected appService: ApplicationService;
    protected cockpitConfigService: CockpitConfigService;
    constructor(stepper: C8yStepper, step: CdkStep, setup: SetupComponent, appState: AppStateService, alert: AlertService, appService: ApplicationService, cockpitConfigService: CockpitConfigService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitSetupStep4Component, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CockpitSetupStep4Component, "c8y-cockpit-setup-step4", never, {}, {}, never, never, true, never>;
}

declare class FeatureConfigComponent {
    config: CockpitConfig;
    onUpdate: EventEmitter<void>;
    updateFeatures(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FeatureConfigComponent, "c8y-feature-config", never, { "config": { "alias": "config"; "required": false; }; }, { "onUpdate": "onUpdate"; }, never, never, true, never>;
}

declare class RootNodeConfigComponent {
    config: CockpitConfig;
    disabled: boolean;
    onUpdate: EventEmitter<void>;
    /**
     * Removes one of the root nodes.
     * @param node The node to remove.
     */
    removeNavigatorNode(node: CockpitConfigRootNode): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RootNodeConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RootNodeConfigComponent, "c8y-root-node-config", never, { "config": { "alias": "config"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "onUpdate": "onUpdate"; }, never, never, true, never>;
}

declare class HomeDashboardConfigComponent {
    private cockpitConfigService;
    config: CockpitConfig;
    /**
     * The types of dashboard that can be configured.
     */
    readonly homeDashboardTypes: typeof HomeDashboardType;
    /**
     * @ignore
     */
    constructor(cockpitConfigService: CockpitConfigService);
    /**
     * @ignore
     */
    dashboardChange(selected: boolean, type: HomeDashboardType): void;
    /**
     * @ignore
     */
    verifySelected(type: HomeDashboardType): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<HomeDashboardConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HomeDashboardConfigComponent, "c8y-home-dashboard-config", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
}

declare class MiscConfigComponent {
    config: CockpitConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<MiscConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MiscConfigComponent, "c8y-misc-config", never, { "config": { "alias": "config"; "required": false; }; }, {}, never, never, true, never>;
}

declare class CockpitSetupStepperButtonsComponent {
    index: any;
    onNext: EventEmitter<void>;
    onBack: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitSetupStepperButtonsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CockpitSetupStepperButtonsComponent, "c8y-cockpit-setup-stepper-buttons", never, { "index": { "alias": "index"; "required": false; }; }, { "onNext": "onNext"; "onBack": "onBack"; }, never, never, true, never>;
}

declare class CockpitConfigModule {
    private service;
    constructor(service: CockpitConfigService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CockpitConfigModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CockpitConfigModule, never, [typeof i1.CoreModule, typeof i2.AssetSelectorModule, typeof i3.PopoverModule, typeof i4.TooltipModule, typeof i5.EcosystemModule, typeof i6.IconSelectorModule, typeof i1.PluginLoadedPipe, typeof CockpitConfigurationComponent, typeof CockpitSetupStep1Component, typeof CockpitSetupStep2Component, typeof CockpitSetupStep3Component, typeof CockpitSetupStep4Component, typeof FeatureConfigComponent, typeof RootNodeConfigComponent, typeof HomeDashboardConfigComponent, typeof MiscConfigComponent, typeof CockpitSetupStepperButtonsComponent], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CockpitConfigModule>;
}

export { COCKPIT_CONFIG_PATH, CockpitConfigGuard, CockpitConfigModule, CockpitConfigService, CockpitConfigurationComponent, CockpitSetupStep1Component, CockpitSetupStep2Component, CockpitSetupStep3Component, CockpitSetupStep4Component, DEFAULT_CONFIG, DEFAULT_HOME_DASHBOARD_NAME, FeatureConfigComponent, HomeDashboardConfigComponent, HomeDashboardType, MiscConfigComponent, RootNodeConfigComponent, USER_HOME_DASHBOARD_NAME };
export type { CockpitConfig, CockpitConfigRootNode };
//# sourceMappingURL=index.d.ts.map