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

Angular modules for Cumulocity IoT applications

import * as i0 from '@angular/core';
import { NgZone, OnInit, OnDestroy, ElementRef } from '@angular/core';
import * as i1 from '@c8y/ngx-components';
import { Tab, AppStateService, RouterService, ActionService, DocLink, ActionBarItem, Breadcrumb, Search, Action, PluginsResolveService, ActionBarFactory, TenantUiService, BreadcrumbFactory, ActionFactory, TabsService, NavigatorNodeFactory, EmptyComponent, ExtensionFactory, TabFactory, OnBeforeSave, WidgetsDashboardComponent, DashboardChildComponent, DynamicComponentDefinition } from '@c8y/ngx-components';
import * as i2 from '@c8y/ngx-components/upgrade/upgraded-services';
import * as rxjs from 'rxjs';
import { Observable, Subject } from 'rxjs';
import { Router } from '@angular/router';
import * as _c8y_client from '@c8y/client';
import { BasicAuth, FetchClient, ICredentials } from '@c8y/client';
import { UpgradeModule as UpgradeModule$1 } from '@angular/upgrade/static';
import { ContextWidgetConfig } from '@c8y/ngx-components/context-dashboard';
import * as i1$1 from '@angular/common';
import * as i3 from '@c8y/ngx-components/assets-navigator';

declare class UpgradeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UpgradeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UpgradeModule, never, [typeof i1.RouterModule, typeof i2.UpgradedServicesModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UpgradeModule>;
}

declare class BridgeService {
    injector: any;
    private appState;
    router: Router;
    private ngZone;
    private routerService;
    private actionService;
    $routeChanges: Observable<any>;
    $ng1RouteChangeSuccess: Observable<any>;
    $ng1RouteChangeStart: Observable<any>;
    $ng1RouteUpdate: Observable<any>;
    $liveTabs: Subject<Tab[]>;
    navigationNodes$: Observable<any>;
    initialNavigationDone: boolean;
    constructor(injector: any, appState: AppStateService, router: Router, ngZone: NgZone, routerService: RouterService, actionService: ActionService);
    /**
     * Ensure that angularjs routes are not using any
     * secondary router outlets
     */
    hookRoute(): void;
    hookViewProvider(): void;
    addRoute(cfg: any): void;
    ng1Routes(): void;
    fixE2eIssues(): void;
    hookLanguage(): void;
    hookTab(): void;
    hookNavigator(): void;
    getTabs(): Observable<any>;
    getQuickLinks(): Promise<DocLink[]>;
    getActionBarItems(): Observable<ActionBarItem>;
    getBreadcrumbs(): Observable<Breadcrumb[]>;
    resolveBreadcrumbsData(data: any): Observable<any[]>;
    getSearch(): Search[];
    getActions(): Observable<Action>;
    fromNg1Event(obj: any, evt: any): Observable<unknown>;
    private hookUserMenu;
}
declare function bridgeServiceFactory(injector: any, appState: AppStateService, router: Router, ngZone: NgZone, routerService: RouterService, actionService: ActionService): BridgeService;
declare const bridgeServiceProvider: {
    provide: typeof BridgeService;
    useFactory: typeof bridgeServiceFactory;
    deps: (string | typeof AppStateService | typeof Router | typeof NgZone | typeof RouterService | typeof ActionService | typeof PluginsResolveService)[];
};

declare class Ng1ActionBarFactoryService implements ActionBarFactory {
    private bridge;
    routeChanges$: Observable<any>;
    $ng1RouteChangeSuccess: Observable<any>;
    constructor(bridge: BridgeService);
    get(): Observable<ActionBarItem>;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng1ActionBarFactoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Ng1ActionBarFactoryService>;
}

declare class AuthBridgeService {
    injector: any;
    private basicAuth;
    private fetchClient;
    private appState;
    private tenantUiService;
    constructor(injector: any, basicAuth: BasicAuth, fetchClient: FetchClient, appState: AppStateService, tenantUiService: TenantUiService);
    updateBasicAuth(credentials: ICredentials): void;
    hookAuth(): void;
    setToken(token?: string, tfa?: string, type?: string): void;
    getPreferredLoginOption(): _c8y_client.ITenantLoginOption;
}
declare function authBridgeServiceFactory(injector: any, basicAuth: BasicAuth, fetchClient: FetchClient, appState: AppStateService, tenantUiService: TenantUiService): AuthBridgeService;
declare const authBridgeServiceProvider: {
    provide: typeof AuthBridgeService;
    useFactory: typeof authBridgeServiceFactory;
    deps: (string | typeof AppStateService | typeof BasicAuth | typeof FetchClient | typeof TenantUiService)[];
};

declare class Ng1BreadcrumbFactoryService implements BreadcrumbFactory {
    private bridge;
    private trigger;
    private breadcrumbs;
    constructor(bridge: BridgeService);
    get(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng1BreadcrumbFactoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Ng1BreadcrumbFactoryService>;
}

declare abstract class HybridAppModule {
    ng1Modules: string[];
    protected upgrade: UpgradeModule$1;
    ngDoBootstrap(): void;
}

declare class Ng1ActionFactoryService implements ActionFactory {
    private bridge;
    private tabs;
    routeChanges$: Observable<any>;
    $location: any;
    constructor(bridge: BridgeService, tabs: TabsService);
    handleTabsRedirect(tabs: any): void;
    get(): Observable<i1.Action>;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng1ActionFactoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Ng1ActionFactoryService>;
}

declare class Ng1NodesFactoryService implements NavigatorNodeFactory {
    private bridge;
    constructor(bridge: BridgeService);
    get(): rxjs.Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng1NodesFactoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Ng1NodesFactoryService>;
}

declare const UPGRADE_ROUTES: {
    path: string;
    component: typeof EmptyComponent;
}[];

declare class Ng1DocsFactoryService implements ExtensionFactory<DocLink> {
    private bridge;
    private links;
    constructor(bridge: BridgeService);
    get(): Promise<DocLink[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng1DocsFactoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Ng1DocsFactoryService>;
}

declare class Ng1TabsFactoryService implements TabFactory {
    private bridge;
    tabsObservable: any;
    constructor(bridge: BridgeService);
    get(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng1TabsFactoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Ng1TabsFactoryService>;
}

declare class DashboardBridgeService {
    dashboardSvc: any;
    compile: any;
    dashboardClipboard: any;
    private ng1Injector;
    private zone;
    private router;
    private contextDashboardService;
    constructor();
    get ng1Components(): any;
    instantiateComponent(widget: any, element: any, dashboardChild: any): Promise<any>;
    instantiateDeviceSelector(element: any, widgetConfig: ContextWidgetConfig): any;
    private loadTemplate;
    private getDashboard;
    private loadConfigTemplate;
    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardBridgeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DashboardBridgeService>;
}

declare class WidgetComponent implements OnInit, OnDestroy, OnBeforeSave {
    private dashboard;
    private dashboardBridgeService;
    private el;
    private dashboardChild;
    ng1Scope: any;
    config: any;
    alerts: any;
    private resizeSubscription?;
    private readonly DEBOUNCE_TIME_UNTIL_WIDGET_HAS_SNAPPED;
    constructor(dashboard: WidgetsDashboardComponent, dashboardBridgeService: DashboardBridgeService, el: ElementRef, dashboardChild: DashboardChildComponent);
    onBeforeSave(): boolean;
    ngOnInit(): Promise<void>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WidgetComponent, [{ optional: true; }, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WidgetComponent, "c8y-widget-legacy", never, {}, {}, never, never, true, never>;
}

declare class Ng1ComponentFactoryService {
    private bridge;
    private components$;
    constructor(bridge: DashboardBridgeService);
    get(): Observable<DynamicComponentDefinition[]>;
    private getComponents;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng1ComponentFactoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Ng1ComponentFactoryService>;
}

declare class LegacyDeviceSelectorComponent implements OnInit, OnDestroy {
    private dashboardBridgeService;
    private el;
    ng1Scope: any;
    config: any;
    constructor(dashboardBridgeService: DashboardBridgeService, el: ElementRef);
    ngOnInit(): Promise<void>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LegacyDeviceSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LegacyDeviceSelectorComponent, "c8y-device-selector-legacy", never, {}, {}, never, never, true, never>;
}

declare class DashboardUpgradeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DashboardUpgradeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DashboardUpgradeModule, never, [typeof i1$1.CommonModule, typeof i1.C8yTranslateModule, typeof i3.AssetSelectorModule, typeof LegacyDeviceSelectorComponent, typeof WidgetComponent], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DashboardUpgradeModule>;
}

declare const ng1ModulesUpgrade: string[];

export { AuthBridgeService, BridgeService, DashboardBridgeService, DashboardUpgradeModule, HybridAppModule, LegacyDeviceSelectorComponent, Ng1ActionBarFactoryService, Ng1ActionFactoryService, Ng1BreadcrumbFactoryService, Ng1ComponentFactoryService, Ng1DocsFactoryService, Ng1NodesFactoryService, Ng1TabsFactoryService, UPGRADE_ROUTES, UpgradeModule, WidgetComponent, authBridgeServiceFactory, authBridgeServiceProvider, bridgeServiceFactory, bridgeServiceProvider, ng1ModulesUpgrade };
//# sourceMappingURL=index.d.ts.map