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

Angular modules for Cumulocity IoT applications

import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';
import * as _c8y_ngx_components from '@c8y/ngx-components';
import { TabFactory, Tab, NavigatorNodeFactory, NavigatorNode, AppStateService, Permissions, ProviderProperties } from '@c8y/ngx-components';
import * as i5 from '@angular/router';
import { Router, CanActivateFn } from '@angular/router';
import * as i0 from '@angular/core';
import { FormlyFieldConfig } from '@ngx-formly/core';

declare abstract class AbstractConnectivityTabFactory implements TabFactory {
    protected router: Router;
    protected guard: {
        canActivate: CanActivateFn;
    };
    constructor(router: Router, guard: {
        canActivate: CanActivateFn;
    });
    get(): any[] | _c8y_ngx_components.TabWithComponent | _c8y_ngx_components.TabWithTemplate<string | any[]> | Observable<Tab>;
    tab(): Tab | Observable<Tab>;
    protected abstract config(): Tab;
}

declare abstract class AbstractConnectivityNodeFactory implements NavigatorNodeFactory {
    protected tabFactory: AbstractConnectivityTabFactory;
    protected readonly connectivityNode: NavigatorNode;
    constructor(tabFactory: AbstractConnectivityTabFactory);
    get(): rxjs.Observable<NavigatorNode[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractConnectivityNodeFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AbstractConnectivityNodeFactory>;
}

declare class ActilityGuard {
    private appState;
    private static readonly applicationName;
    private showActilityProvider;
    constructor(appState: AppStateService);
    canActivate(): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActilityGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActilityGuard>;
}

declare class ActilityTabFactory extends AbstractConnectivityTabFactory {
    protected router: Router;
    protected guard: ActilityGuard;
    private tabConfig;
    constructor(router: Router, guard: ActilityGuard);
    protected config(): Tab;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActilityTabFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActilityTabFactory>;
}

declare class ActilityNodeFactory extends AbstractConnectivityNodeFactory {
    protected tabFactory: ActilityTabFactory;
    constructor(tabFactory: ActilityTabFactory);
    static ɵfac: i0.ɵɵFactoryDeclaration<ActilityNodeFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActilityNodeFactory>;
}

declare class ActilityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ActilityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ActilityModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ActilityModule>;
}

declare class SigfoxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SigfoxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SigfoxModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SigfoxModule>;
}

declare class LoriotModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LoriotModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LoriotModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LoriotModule>;
}

declare class ConnectivityModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectivityModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ConnectivityModule, never, [typeof _c8y_ngx_components.CoreModule, typeof ActilityModule, typeof SigfoxModule, typeof LoriotModule, typeof i5.RouterModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ConnectivityModule>;
}

declare class LoriotGuard {
    private appState;
    private static readonly applicationName;
    private showLoriotProvider;
    constructor(appState: AppStateService);
    canActivate(): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoriotGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoriotGuard>;
}

declare class LoriotTabFactory extends AbstractConnectivityTabFactory {
    protected router: Router;
    protected guard: LoriotGuard;
    private tabConfig;
    constructor(router: Router, guard: LoriotGuard);
    protected config(): Tab;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoriotTabFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoriotTabFactory>;
}

declare class LoriotNodeFactory extends AbstractConnectivityNodeFactory {
    protected tabFactory: LoriotTabFactory;
    constructor(tabFactory: LoriotTabFactory);
    static ɵfac: i0.ɵɵFactoryDeclaration<LoriotNodeFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoriotNodeFactory>;
}

declare class SigfoxGuard {
    private appState;
    private static readonly applicationName;
    private showSigfoxProvider;
    constructor(appState: AppStateService);
    canActivate(): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SigfoxGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SigfoxGuard>;
}

declare class SigfoxTabFactory extends AbstractConnectivityTabFactory {
    protected router: Router;
    protected guard: SigfoxGuard;
    private tabConfig;
    constructor(router: Router, guard: SigfoxGuard);
    protected config(): Tab;
    static ɵfac: i0.ɵɵFactoryDeclaration<SigfoxTabFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SigfoxTabFactory>;
}

declare class SigfoxNodeFactory extends AbstractConnectivityNodeFactory {
    protected tabFactory: SigfoxTabFactory;
    constructor(tabFactory: SigfoxTabFactory);
    static ɵfac: i0.ɵɵFactoryDeclaration<SigfoxNodeFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SigfoxNodeFactory>;
}

declare class SimGuard {
    private permissions;
    private appState;
    private static readonly applicationName;
    private showSimProvider;
    constructor(permissions: Permissions, appState: AppStateService);
    canActivate(): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SimGuard, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SimGuard>;
}

declare function encodeFiles(model: ProviderProperties, fields: FormlyFieldConfig[]): Promise<ProviderProperties>;
declare class SimModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SimModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SimModule, never, [typeof _c8y_ngx_components.ProviderConfigurationModule], never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SimModule>;
}

export { AbstractConnectivityNodeFactory, AbstractConnectivityTabFactory, ActilityGuard, ActilityModule, ActilityNodeFactory, ActilityTabFactory, ConnectivityModule, LoriotGuard, LoriotModule, LoriotNodeFactory, LoriotTabFactory, SigfoxGuard, SigfoxModule, SigfoxNodeFactory, SigfoxTabFactory, SimGuard, SimModule, encodeFiles };
//# sourceMappingURL=index.d.ts.map