import * as lottie_web from 'lottie-web';
import * as i0 from '@angular/core';
import { PipeTransform, EventEmitter, InjectionToken, ViewContainerRef, ElementRef, OnInit, DoCheck, OnDestroy, AfterViewInit, ChangeDetectorRef, OnChanges, SimpleChanges, TemplateRef, Injector } from '@angular/core';
import * as _angular_platform_browser from '@angular/platform-browser';
import { DomSanitizer } from '@angular/platform-browser';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Subject, Subscription, Observable } from 'rxjs';
import * as lodash from 'lodash';
import lodash__default from 'lodash';
import * as i3 from '@angular/forms';
import { ControlValueAccessor } from '@angular/forms';
import * as i1 from '@angular/router';
import { Router, ActivatedRoute, CanDeactivate } from '@angular/router';
import { NGXLogger } from 'ngx-logger';
import { HttpBackend, HttpClient } from '@angular/common/http';
import * as i2 from '@angular/common';
import { Location } from '@angular/common';
import * as i116 from '@angular/material/dialog';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import moment from 'moment/moment';
import * as i127 from 'ag-grid-angular';
import { IHeaderAngularComp, ICellRendererAngularComp, ITooltipAngularComp } from 'ag-grid-angular';
import { IHeaderParams, ICellRendererParams, ITooltipParams } from 'ag-grid-community';
import * as i130 from 'ang-jsoneditor';
import { JsonEditorComponent } from 'ang-jsoneditor';
import * as i119 from '@angular/material/datepicker';
import { MatCalendar, MatDateRangePicker } from '@angular/material/datepicker';
import * as i120 from '@angular/material/core';
import { DateAdapter } from '@angular/material/core';
import * as i133 from 'ngx-lottie';
import { AnimationOptions } from 'ngx-lottie';
import * as i123 from '@angular/material/select';
import { MatSelect } from '@angular/material/select';
import { OAuthService } from 'angular-oauth2-oidc';
import moment$1 from 'moment';
import * as i117 from '@angular/material/radio';
import * as i121 from '@angular/material/form-field';
import * as i122 from '@angular/material/input';
import * as i124 from '@angular/material/button';
import * as i125 from '@angular/material/icon';
import * as i126 from '@angular/cdk/overlay';
import * as i128 from 'angularx-qrcode';
import * as i129 from 'ng-click-outside';
import * as i131 from '@angular/material/tooltip';
import * as i132 from '@angular/material/autocomplete';

declare class SafePipe implements PipeTransform {
    private sanitized;
    constructor(sanitized: DomSanitizer);
    transform(value: string): _angular_platform_browser.SafeHtml;
    static ɵfac: i0.ɵɵFactoryDeclaration<SafePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SafePipe, "safe", false>;
}

declare const SHAREDZ_EXTENSION: InjectionToken<any>;
type ExtensionEventType = 'formDataUpdated' | 'attributesChanged' | 'service-attributes-changed' | 'identity-attributes-changed' | 'policy-type-changed' | 'policy-semantic-changed' | 'tableDataUpdated' | string;
interface ExtensionEvent<TData = any, TResult = any> {
    type: ExtensionEventType;
    data?: TData;
}
interface ExtensionService {
    formDataChanged: BehaviorSubject<any>;
    closed: EventEmitter<any>;
    closeAfterSave: boolean;
    moreActions?: any[];
    listActions?: any[];
    consoleActionTriggered?: EventEmitter<any>;
    disabledComponents?: any[];
    showApiCalls?: boolean;
    useDeleteSplitButton?: boolean;
    emitEvent?<TData, TResult>(event: ExtensionEvent<TData, TResult>): Promise<TResult | undefined>;
    extendOnInit(): void;
    extendAfterViewInits(extentionPoints: any): void;
    updateFormData(data: any): void;
    validateData(): Promise<any>;
    formDataSaved(data: any): Promise<any>;
    processTableColumns(tableColumns: any): any[];
}
declare class ExtensionsNoopService implements ExtensionService {
    formDataChanged: BehaviorSubject<any>;
    closed: EventEmitter<any>;
    consoleActionTriggered: EventEmitter<any>;
    closeAfterSave: boolean;
    moreActions: any[];
    disabledComponents: any[];
    constructor();
    emitEvent<TData, TResult>(event: ExtensionEvent<TData, TResult>): Promise<TResult | undefined>;
    extendOnInit(): void;
    extendAfterViewInits(extentionPoints: any): void;
    updateFormData(data: any): void;
    formDataSaved(data: any): Promise<any>;
    validateData(): Promise<any>;
    processTableColumns(tableColumns: any): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtensionsNoopService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ExtensionsNoopService>;
}

declare class ExtendableComponent {
    beforeTitleVC: ViewContainerRef | undefined;
    afterTitleVC: ViewContainerRef | undefined;
    beforeButtonsVC: ViewContainerRef | undefined;
    afterButtonsVC: ViewContainerRef | undefined;
    extSvc: ExtensionService | undefined;
    constructor();
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExtendableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExtendableComponent, "ng-component", never, {}, {}, never, never, false, never>;
}

declare class StringInputComponent {
    _fieldName: string;
    _idName: string;
    set fieldName(name: string);
    helpText: any;
    fieldValue: string;
    placeholder: string;
    parentage: string[];
    labelColor: string;
    fieldClass: string;
    error: string;
    autocomplete: string;
    required: boolean;
    fieldValueChange: EventEmitter<string>;
    valueChange: Subject<string>;
    _isValid: boolean;
    setIsValid(isValid: any): void;
    onKeyup(): void;
    emitEventsDebounced: lodash.DebouncedFunc<() => void>;
    emitEvents(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StringInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StringInputComponent, "lib-string-input", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "fieldValue": { "alias": "fieldValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "fieldClass": { "alias": "fieldClass"; "required": false; }; "error": { "alias": "error"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "fieldValueChange": "fieldValueChange"; }, never, never, false, never>;
}

declare class NumberInputComponent {
    _fieldName: string;
    _idName: string;
    set fieldName(name: string);
    helpText: any;
    fieldValue: number | undefined;
    placeholder: string;
    parentage: string[];
    labelColor: string;
    fieldClass: string;
    error: string;
    fieldValueChange: EventEmitter<number>;
    valueChange: Subject<number>;
    _isValid: boolean;
    private _emitEventsDebounced;
    constructor();
    setIsValid(isValid: any): void;
    onKeyup(): void;
    emitEvents(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NumberInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NumberInputComponent, "lib-number-input", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "fieldValue": { "alias": "fieldValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "fieldClass": { "alias": "fieldClass"; "required": false; }; "error": { "alias": "error"; "required": false; }; }, { "fieldValueChange": "fieldValueChange"; }, never, never, false, never>;
}

declare class BooleanToggleInputComponent {
    _fieldName: string;
    _idName: string;
    set fieldName(name: string);
    fieldValue: boolean;
    parentage: string[];
    labelColor: string;
    fieldClass: string;
    error: string;
    fieldValueChange: EventEmitter<boolean>;
    valueChange: Subject<boolean>;
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanToggleInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BooleanToggleInputComponent, "lib-boolean-toggle-input", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "fieldValue": { "alias": "fieldValue"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "fieldClass": { "alias": "fieldClass"; "required": false; }; "error": { "alias": "error"; "required": false; }; }, { "fieldValueChange": "fieldValueChange"; }, never, never, false, never>;
}

declare class ObjectComponent {
    wrapperContents: ViewContainerRef;
    _fieldName: string;
    _idName: string;
    set fieldName(name: string);
    itemData: any;
    parentage: string[];
    bcolor: string;
    labelColor: string;
    showAdd: boolean;
    addedItems: any[];
    open: boolean;
    itemAdded: EventEmitter<boolean>;
    itemSelected: EventEmitter<any>;
    itemRemoved: EventEmitter<any>;
    constructor();
    addClicked(): void;
    itemClicked(item: any, index: any): void;
    toggleOpen(event: any, source: any): void;
    removeItemClicked(item: any, index: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectComponent, "lib-object", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "itemData": { "alias": "itemData"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "bcolor": { "alias": "bcolor"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "showAdd": { "alias": "showAdd"; "required": false; }; "addedItems": { "alias": "addedItems"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "itemAdded": "itemAdded"; "itemSelected": "itemSelected"; "itemRemoved": "itemRemoved"; }, never, never, false, never>;
}

declare class SelectorInputComponent {
    _fieldName: string;
    _idName: string;
    _valueList: any[];
    listIsObject: boolean;
    hideSelect: boolean;
    set fieldName(name: string);
    _fieldValue: string;
    set fieldValue(val: string);
    get fieldValue(): string;
    helpText: any;
    placeholder: string;
    parentage: string[];
    set valueList(list: any[]);
    labelColor: string;
    fieldClass: string;
    error: string;
    fieldValueChange: EventEmitter<string>;
    valueChange: Subject<string>;
    _isValid: boolean;
    setIsValid(isValid: any): void;
    selected(): void;
    reInitSelect(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectorInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectorInputComponent, "lib-selector-input", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "fieldValue": { "alias": "fieldValue"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "valueList": { "alias": "valueList"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "fieldClass": { "alias": "fieldClass"; "required": false; }; "error": { "alias": "error"; "required": false; }; }, { "fieldValueChange": "fieldValueChange"; }, never, never, false, never>;
}

declare class TextListInputComponent {
    _fieldName: string;
    _idName: string;
    set fieldName(name: string);
    _fieldValue: any;
    set fieldValue(val: any);
    get fieldValue(): any;
    placeholder: string;
    parentage: string[];
    labelColor: string;
    fieldClass: string;
    error: string;
    fieldValueChange: EventEmitter<string>;
    valueChange: Subject<string>;
    onKeyup(event: any): void;
    emitEventsDebounced: lodash.DebouncedFunc<() => void>;
    emitEvents(): void;
    _isValid: boolean;
    setIsValid(isValid: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextListInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextListInputComponent, "lib-text-list-input", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "fieldValue": { "alias": "fieldValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "fieldClass": { "alias": "fieldClass"; "required": false; }; "error": { "alias": "error"; "required": false; }; }, { "fieldValueChange": "fieldValueChange"; }, never, never, false, never>;
}

declare class ChipsInputComponent implements ControlValueAccessor {
    placeholder: string;
    inputId?: string;
    addOnBlur: boolean;
    allowDuplicate: boolean;
    separator: string;
    invalid: boolean;
    onAdd: EventEmitter<any>;
    onRemove: EventEmitter<any>;
    onModelChange: EventEmitter<string[]>;
    onBlur: EventEmitter<FocusEvent>;
    keyup: EventEmitter<KeyboardEvent>;
    chipInput?: ElementRef<HTMLInputElement>;
    value: string[];
    disabled: boolean;
    focused: boolean;
    private onChange;
    private onTouched;
    writeValue(val: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    focusInput(): void;
    onFocus(): void;
    handleBlur(event?: FocusEvent): void;
    onPaste(event: ClipboardEvent): void;
    onKeydown(event: KeyboardEvent): void;
    removeAtIndex(index: number, event?: Event): void;
    private commitFromInput;
    private addTokens;
    private propagateModel;
    private clearInput;
    private splitIntoTokens;
    static ɵfac: i0.ɵɵFactoryDeclaration<ChipsInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ChipsInputComponent, "lib-chips-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "addOnBlur": { "alias": "addOnBlur"; "required": false; }; "allowDuplicate": { "alias": "allowDuplicate"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; }, { "onAdd": "onAdd"; "onRemove": "onRemove"; "onModelChange": "onModelChange"; "onBlur": "onBlur"; "keyup": "keyup"; }, never, never, false, never>;
}

declare class CheckboxListInputComponent {
    items: any[];
    _fieldName: string;
    _idName: string;
    set fieldName(name: string);
    _fieldValue: string[];
    set fieldValue(vals: string[]);
    get fieldValue(): string[];
    placeholder: string;
    parentage: string[];
    set valueList(list: string[]);
    labelColor: string;
    fieldClass: string;
    error: string;
    fieldValueChange: EventEmitter<string[]>;
    valueChange: Subject<string[]>;
    updateCheckedItems(): void;
    updateCheckboxItems(list: string[]): void;
    updateFieldVal(): void;
    _isValid: boolean;
    setIsValid(isValid: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxListInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxListInputComponent, "lib-checkbox-list-input", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "fieldValue": { "alias": "fieldValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "valueList": { "alias": "valueList"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "fieldClass": { "alias": "fieldClass"; "required": false; }; "error": { "alias": "error"; "required": false; }; }, { "fieldValueChange": "fieldValueChange"; }, never, never, false, never>;
}

declare class ValidationService {
    validateIdentity(identity: any): {
        isValid: boolean;
        errors: {};
    };
    getPortRanges(allowedPortRanges: any): any[];
    combinePortRanges(allowedPortRanges: any): any[];
    parsePortRanges(portRanges: any): any[];
    validatePortRanges(portRanges: any): boolean;
    isValidPort(port: any): boolean;
    isValidInterceptHost(address: any): boolean;
    isValidPEM(cert: any): boolean;
    isValidURI(uri: any): boolean;
    isValidJSON(val: any): boolean;
    redefineObject(obj: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationService>;
}

declare class ProtocolAddressPortInputComponent implements OnInit, DoCheck {
    private validationService;
    protocolList: any;
    showProtocol: boolean;
    showAddress: boolean;
    showHostName: boolean;
    showPort: boolean;
    disableProtocol: boolean;
    disableAddress: boolean;
    disableHostName: boolean;
    disablePort: boolean;
    protocol: string;
    address: string;
    hostname: string;
    port: number;
    parentage: string[];
    labelColor: string;
    labelPrefix: string;
    fieldClass: string;
    error: string;
    fieldValueChange: EventEmitter<any>;
    portChange: EventEmitter<number>;
    addressChange: EventEmitter<string>;
    hostnameChange: EventEmitter<string>;
    protocolChange: EventEmitter<string>;
    valueChange: Subject<any>;
    protocolFieldName: string;
    addressFieldName: string;
    hostnameFieldName: string;
    portFieldName: string;
    checkAddressDebounced: lodash__default.DebouncedFuncLeading<() => void>;
    errors: {};
    props: {
        key: string;
        value: any;
    }[];
    constructor(validationService: ValidationService);
    ngOnInit(): void;
    ngDoCheck(): void;
    _addressChanged: boolean;
    _prevAddress: any;
    checkAddress(): void;
    update(): void;
    get className(): string;
    getProperties(): {
        key: string;
        value: any;
    }[];
    setValidationErrors(propertyPath: string, validationErrors: any[]): void;
    isValid(): boolean;
    setProperties(data: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProtocolAddressPortInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProtocolAddressPortInputComponent, "lib-protocol-address-port-input", never, { "protocolList": { "alias": "protocolList"; "required": false; }; "showProtocol": { "alias": "showProtocol"; "required": false; }; "showAddress": { "alias": "showAddress"; "required": false; }; "showHostName": { "alias": "showHostName"; "required": false; }; "showPort": { "alias": "showPort"; "required": false; }; "disableProtocol": { "alias": "disableProtocol"; "required": false; }; "disableAddress": { "alias": "disableAddress"; "required": false; }; "disableHostName": { "alias": "disableHostName"; "required": false; }; "disablePort": { "alias": "disablePort"; "required": false; }; "protocol": { "alias": "protocol"; "required": false; }; "address": { "alias": "address"; "required": false; }; "hostname": { "alias": "hostname"; "required": false; }; "port": { "alias": "port"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "labelPrefix": { "alias": "labelPrefix"; "required": false; }; "fieldClass": { "alias": "fieldClass"; "required": false; }; "error": { "alias": "error"; "required": false; }; }, { "fieldValueChange": "fieldValueChange"; "portChange": "portChange"; "addressChange": "addressChange"; "hostnameChange": "hostnameChange"; "protocolChange": "protocolChange"; }, never, never, false, never>;
}

declare class SideNavbarComponent {
    private router;
    currentNav: any;
    version: string;
    open: boolean;
    isOpened: boolean;
    url: string;
    constructor(router: Router, currentNav: any);
    ngOnInit(): void;
    toggleList(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SideNavbarComponent, "lib-side-navbar", never, { "version": { "alias": "version"; "required": false; }; }, {}, never, never, false, never>;
}

declare class PasswordInputComponent {
    _fieldName: string;
    _idName: string;
    set fieldName(name: string);
    fieldValue: string;
    placeholder: string;
    parentage: string[];
    labelColor: string;
    fieldClass: string;
    error: string;
    autocomplete: string;
    required: boolean;
    fieldValueChange: EventEmitter<string>;
    valueChange: Subject<string>;
    onKeyup(): void;
    emitEventsDebounced: lodash.DebouncedFunc<() => void>;
    emitEvents(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordInputComponent, "lib-password-input", never, { "fieldName": { "alias": "fieldName"; "required": false; }; "fieldValue": { "alias": "fieldValue"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "parentage": { "alias": "parentage"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "fieldClass": { "alias": "fieldClass"; "required": false; }; "error": { "alias": "error"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "fieldValueChange": "fieldValueChange"; }, never, never, false, never>;
}

declare class LoggerService {
    logger: NGXLogger;
    private clientLevel;
    private logJson;
    constructor(logger: NGXLogger);
    setUser(userId: string, authenticated: boolean): void;
    setOrg(orgId: string): void;
    setAzureSubscriptionId(azureSubscriptionId: string): void;
    setNetworkId(networkId: string): void;
    setRoute(route: string): void;
    setServerLoggingUrl(url: string): void;
    setClientLevel(level: string): void;
    setServerLevel(level: string): void;
    debug(message: string, data?: any): void;
    error(message: string, data?: any): void;
    warn(message: string, data?: any): void;
    info(message: string, data?: any): void;
    log(message: string, data?: any): void;
    trace(message: string, data?: any): void;
    private resetLogJson;
    private setMessageAndData;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
}

declare class GrowlerModel {
    title: string;
    subtitle: string;
    level: string;
    content: string;
    constructor(level?: string, title?: string, subtitle?: string, content?: string);
}

declare class GrowlerService {
    private logger;
    constructor(logger: LoggerService);
    updateGrowlerEmitter: boolean;
    private data;
    data$: rxjs.Observable<GrowlerModel>;
    private updateGrowlerSource;
    updateGrowler: rxjs.Observable<boolean>;
    private sessionGrowlerObject;
    private loginGrowlerPaths;
    show(data: GrowlerModel): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrowlerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GrowlerService>;
}

type FilterObj = {
    filterName: string;
    columnId: string;
    value: any;
    label: string;
    type?: string;
    hidden?: boolean;
    verb?: string;
};
declare class DataTableFilterService {
    private location;
    private router;
    private activatedRoute;
    filters: FilterObj[];
    currentPage: number;
    filtersChanged: BehaviorSubject<FilterObj[]>;
    filtering: BehaviorSubject<boolean>;
    pageChanged: BehaviorSubject<any>;
    currentQueryParams: any[];
    constructor(location: Location, router: Router, activatedRoute: ActivatedRoute);
    updateFilter(filterObj: FilterObj): void;
    removeFilter(filterObj: FilterObj): void;
    getFilterString(key: string): string;
    changePage(page: any): void;
    clearFilters(): void;
    storeFilters(): void;
    getStoredFilters(): any;
    updateUrlParameters(filtersToRemove?: any[]): void;
    getUrlFiltersMap(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableFilterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataTableFilterService>;
}

declare abstract class SettingsServiceClass {
    protected httpBackend: HttpBackend;
    protected growlerService: GrowlerService;
    name: string;
    settings: any;
    versionData: any;
    settingsChange: BehaviorSubject<any>;
    rejectUnauthorized: boolean;
    port: number;
    portTLS: number;
    apiVersions: any[];
    capabilities: string[];
    edgeOidcPath: string | null;
    protocol: string;
    host: string;
    httpClient: HttpClient;
    zitiSemver: string;
    allowControllerAdd: boolean;
    supportedFeatures: any;
    constructor(httpBackend: HttpBackend, growlerService: GrowlerService);
    abstract init(): any;
    abstract controllerSave(name: string, url: string): any;
    abstract initApiVersions(url: any): any;
    abstract loadSettings(): any;
    abstract hasSession(): any;
    oidcAvailable(): boolean;
    setOidcCapabilities(versionData: any): void;
    clearOidcCapabilities(): void;
    abstract isHAEnabled(): boolean;
    abstract getHAControllers(): any[];
    abstract getActiveSessions(): Map<string, string>;
    abstract getJwtToken(): string | null;
    abstract hasValidJwtToken(): boolean;
    abstract setJwtToken(token: string): void;
    get(): void;
    set(data: any): void;
    version(): void;
    getHttpOptions(): any;
    addContoller(name: string, url: string): any;
    abstract addHAController(url: string, name: string): void;
    abstract removeHAController(url: string): void;
    abstract setControllerSession(url: string, sessionToken: string): void;
    abstract getControllerSession(url: string): string | null;
    abstract clearControllerSessions(): void;
    abstract clearJwtToken(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsServiceClass, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsServiceClass>;
}

declare const ZITI_DATA_SERVICE: InjectionToken<ZitiDataService>;
declare abstract class ZitiDataService {
    protected logger: LoggerService;
    protected growler: GrowlerService;
    protected settingsService: SettingsServiceClass;
    protected httpClient: HttpClient;
    protected router: Router;
    static NODE_DATA_SERVICE_TYPE: string;
    static CONTROLLER_DATA_SERVICE_TYPE: string;
    dataServiceType: string;
    get DEFAULT_PAGING(): {
        filter: string;
        noSearch: boolean;
        order: string;
        page: number;
        searchOn: string;
        sort: string;
        total: number;
    };
    constructor(logger: LoggerService, growler: GrowlerService, settingsService: SettingsServiceClass, httpClient: HttpClient, router: Router);
    private readonly injector;
    /** Resolved lazily to break the circular dependency: ManagementPermissionsService → ZITI_DATA_SERVICE → ManagementPermissionsService. */
    private get managementPermissions();
    /** Empty list response returned when the user lacks read permission for the requested resource. */
    private static readonly EMPTY_READ_RESULT;
    abstract post(type: any, model: any, chained?: any, contentType?: any): Promise<any>;
    abstract put(type: any, model: any, id: any, chained?: any): Promise<any>;
    abstract patch(type: any, model: any, id: any, chained?: any): Promise<any>;
    abstract doGet(type: string, paging: any, filters: FilterObj[], url?: any, useClient?: any): Promise<any>;
    abstract doGetSubdata(entityType: string, id: any, dataType: string, paging?: any, contentType?: any, filters?: any): Promise<any>;
    get(type: string, paging: any, filters: FilterObj[], url?: any, useClient?: any): Promise<any>;
    getSubdata(entityType: string, id: any, dataType: string, paging?: any, contentType?: any, filters?: any): Promise<any>;
    abstract saveSubdata(entityType: string, id: any, dataType: string, params: any): Promise<any>;
    abstract deleteSubdata(entityType: string, id: any, dataType: string, params: any): Promise<any>;
    abstract delete(type: string, id: string): Promise<any>;
    abstract call(url: string, prefix?: string): Promise<any>;
    abstract callHAControllers(url: string, prefix?: string): Promise<any>;
    abstract resetEnrollment(id: string, date: string): Promise<any>;
    abstract deleteEnrollment(enrollmentId: string): Promise<any>;
    abstract reissueEnrollment(id: string, date: string): Promise<any>;
    abstract resetMFA(id: string): Promise<any>;
    abstract resetPassword(oldPass: any, newPass: any, confirmPass: any): Promise<any>;
    abstract schema(data: any): Promise<any>;
    getRoleFilter(roleAttributes: any, semantic?: string): any[];
    getErrorMessage(resp: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZitiDataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZitiDataService>;
}

declare class Terminator {
    service: any;
    identity: any;
    router: any;
    binding: string;
    precedence: string;
    address: string;
    cost: number;
    identitySecret: string;
}

declare class TerminatorFormService {
    private dataService;
    private extService;
    private growlerService;
    private validationService;
    items: any[];
    errors: any[];
    saveDisabled: boolean;
    serviceNamedAttributes: any[];
    identityNamedAttributes: any[];
    routerNamedAttributes: any[];
    selectedServiceNamedAttributes: any[];
    selectedIdentityNamedAttributes: any[];
    selectedRouterNamedAttributes: any[];
    serviceNamedAttributesMap: any;
    identityNamedAttributesMap: any;
    routerNamedAttributesMap: any;
    constructor(dataService: ZitiDataService, extService: ExtensionService, growlerService: GrowlerService, validationService: ValidationService);
    save(formData: any): any;
    getTerminatorDataModel(formData: any, isUpdate: any): Terminator;
    getIdentityNamedAttributes(): Promise<any>;
    getServiceNamedAttributes(): Promise<any>;
    getRouterNamedAttributes(): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TerminatorFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TerminatorFormService>;
}

declare class SchemaService {
    private growlerService;
    data: {};
    formId: any;
    value: {};
    codeView: any;
    timeoutId: any;
    suggesting: any;
    suggestId: any;
    suggestingField: string;
    propertyExcludes: any[];
    reservedProperties: any[];
    reservedPropertiesMap: any;
    requiredProperties: any[];
    subscriptions: Subscription;
    private items;
    private bColorArray;
    private lColorArray;
    constructor(growlerService: GrowlerService);
    /** DOM helpers (replacing jQuery): id prefix and element access */
    private _prefix;
    private _id;
    private _q;
    private _qAll;
    getType(property: any): any;
    renderSchema(schema: any, dynamicForm: any, lColorArray: any, bColorArray: any, formData: any): any[];
    render(schema: any, view: ViewContainerRef, lColorArray: string[], bColorArray: string[]): any[];
    validate(schema: any, formData: any): any;
    validateFields(schema: any, formData: any, parentage?: string): any;
    validateField(key: any, schema: any, formData: any, property: any, parentage: any): any;
    setValue(schema: any, key: string, type: string, value: any, parentage: string[]): any;
    getValue(key: string, property: any, json: any, parentage: string[]): any;
    getListValue(id: string): any[];
    validateProperty(schema: any, key: string, property: any, parentage: string[]): void;
    private buildNestedContainer;
    private buildBooleanField;
    private buildTextField;
    private buildNumericField;
    private buildSelectField;
    private buildCheckBoxListField;
    checkBoxChanged(event: any, key: any, componentRef: any): void;
    private buildTextListField;
    private buildPortRanges;
    private buildForwardingConfig;
    private buildProtocolAddressPort;
    private getLabel;
    private addFields;
    addSubscribers(item: any): void;
    itemDataValid(item: any): boolean;
    addItemData(item: any): {};
    private addFieldToParentItem;
    private addSpecialFields;
    private addField;
    private addError;
    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SchemaService>;
}

declare const SETTINGS_SERVICE: InjectionToken<SettingsServiceClass>;
declare class SettingsService extends SettingsServiceClass {
    httpBackend: HttpBackend;
    growlerService: GrowlerService;
    allowControllerAdd: boolean;
    constructor(httpBackend: HttpBackend, growlerService: GrowlerService);
    init(): Promise<void>;
    loadSettings(): void;
    hasSession(): boolean;
    controllerSave(name: string, url: string): void;
    initApiVersions(url: string): Promise<any>;
    /**
     * Add an HA controller to the cluster
     */
    addHAController(url: string, name: string): void;
    /**
     * Remove an HA controller from the cluster
     */
    removeHAController(url: string): void;
    /**
     * Get all active sessions for HA controllers
     */
    getActiveSessions(): Map<string, string>;
    /**
     * Set session token for an HA controller
     */
    setControllerSession(url: string, sessionToken: string): void;
    /**
     * Get session token for a specific controller
     */
    getControllerSession(url: string): string | null;
    /**
     * Clear all HA controller sessions
     */
    clearControllerSessions(): void;
    /**
     * Check if HA is enabled
     */
    isHAEnabled(): boolean;
    /**
     * Get all HA controllers
     */
    getHAControllers(): any[];
    /**
     * Set JWT token for authentication
     */
    setJwtToken(token: string): void;
    /**
     * Get JWT token
     */
    getJwtToken(): string | null;
    /**
     * Clear JWT token
     */
    clearJwtToken(): void;
    /**
     * Check if JWT token exists and is not expired
     */
    hasValidJwtToken(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsService>;
}

declare const SAVE_DENIED_BY_PERMISSION_TOOLTIP = "You do not have permission to save changes.";
/** Maps ZAC entityType strings to controller permission entity keys. */
declare const API_RESOURCE_TO_ENTITY_PERMISSION: Record<string, string>;
declare class ManagementPermissionsService {
    private readonly settings;
    private readonly zitiData;
    readonly saveDeniedTooltip = "You do not have permission to save changes.";
    private readonly permissionSet;
    private identityIsAdmin;
    /** Legacy controller, failed refresh, or empty permissions — keep prior UX (no gating). */
    private unrestricted;
    private readonly versionSubject;
    readonly stateVersion$: rxjs.Observable<number>;
    /** Coalesce overlapping current-identity HTTP calls (debounce + rapid settings churn). */
    private identityLoadPromise;
    constructor(settings: SettingsServiceClass, zitiData: ZitiDataService);
    private bumpVersion;
    clear(): void;
    refresh(): Promise<void>;
    private loadCurrentIdentity;
    private fetchCurrentIdentity;
    private applyLegacyMode;
    isUnrestricted(): boolean;
    private isAdmin;
    isAdminReadonly(): boolean;
    /** True once fetchCurrentIdentity() (or clear()) has run at least once — version > 0. */
    get permissionsLoaded(): boolean;
    private resolveEntityKey;
    private hasEntityGrant;
    private hasActionGrant;
    canRead(apiResource: string): boolean;
    canCreate(apiResource: string): boolean;
    canUpdate(apiResource: string): boolean;
    canDelete(apiResource: string): boolean;
    /** Strict read-only form UI: no write permission for this resource (covers admin_readonly and missing entity grant). */
    useStrictReadonlyFormUi(apiResource: string, isEdit: boolean): boolean;
    isSaveDisabled(apiResource: string, isEdit: boolean): boolean;
    isMenuActionAllowed(apiResource: string, action: string): boolean;
    isTableHeaderActionAllowed(apiResource: string, action: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ManagementPermissionsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ManagementPermissionsService>;
}

declare class Entity {
    name: '';
}
declare const KEY_CODES: {
    LEFT_ARROW: number;
    UP_ARROW: number;
    RIGHT_ARROW: number;
    DOWN_ARROW: number;
};
declare abstract class ProjectableForm extends ExtendableComponent implements DoCheck, OnInit {
    protected growlerService: GrowlerService;
    protected extService: ExtensionService;
    protected zitiService: ZitiDataService;
    protected router?: Router;
    protected route?: ActivatedRoute;
    protected location?: Location;
    protected settingsService?: SettingsService;
    protected dialogForm?: MatDialog;
    isModal: boolean;
    abstract close: EventEmitter<any>;
    _formData: any;
    set formData(data: any);
    get formData(): any;
    _entityId: String;
    set entityId(data: String);
    get entityId(): String;
    dataChange: EventEmitter<any>;
    nameFieldInput: ElementRef;
    scrollContainer: ElementRef;
    abstract clear(): void;
    abstract save(): void;
    dataInit: boolean;
    errors: any;
    protected entityType: string;
    protected entityClass: any;
    isLoading: boolean;
    protected usePreviousLocation: boolean;
    moreActions: any[];
    multiActions: any[];
    tagElements: any;
    tagData: any;
    hideTags: boolean;
    initData: any;
    _dataChange: boolean;
    apiOptions: {
        id: string;
        label: string;
    }[];
    basePath: string;
    baseHref: any;
    previousRoute: any;
    showMore: boolean;
    _settings: any;
    checkDataChangeDebounced: lodash.DebouncedFunc<() => void>;
    ignoreDataChange: boolean;
    isScrolled: boolean;
    subscription: Subscription;
    protected readonly managementPermissions: ManagementPermissionsService;
    formInit: boolean;
    formContainer: ElementRef;
    get showApiCalls(): boolean;
    protected constructor(growlerService: GrowlerService, extService: ExtensionService, zitiService: ZitiDataService, router?: Router, route?: ActivatedRoute, location?: Location, settingsService?: SettingsService, dialogForm?: MatDialog);
    get isEdit(): boolean;
    get formPermissionSaveDisabled(): boolean;
    get formPermissionSaveTooltip(): string;
    canReadRelated(apiResource: string): boolean;
    get useStrictReadonlyForm(): boolean;
    /** Blocks save from shortcuts/callbacks when the controller denies create/update for this resource. */
    protected canSaveByPermissions(): boolean;
    get zacManagementReadonlyHostClass(): boolean;
    ngAfterViewInit(skipFocus?: boolean): void;
    ngOnInit(): void;
    initBaseHref(): void;
    showMoreChanged(showMore: any): void;
    loadTags(): void;
    getTagValues(): any[];
    closeForm(refresh?: boolean, ignoreChanges?: boolean, data?: any, event?: any): void;
    closeModal(refresh?: boolean, ignoreChanges?: boolean, data?: any, event?: any): void;
    returnToListPage(): void;
    ngDoCheck(): void;
    protected checkDataChange(): void;
    omitEmptyData(object: any): any;
    omitDataIteratee(val: any): boolean;
    copyToClipboard(val: any): void;
    getRolesCLIVariable(selectedRoles: any): string;
    getRolesCURLVariable(selectedRoles: any): string;
    canDeactivate(): boolean;
    protected entityUpdated(): void;
    getRoleAttributes(type: string): Promise<any>;
    private deleteConfirmDialogRef;
    protected deleteEntity(): void;
    protected deleteServiceWithOrphans(): Promise<any>;
    protected openPreviewDeletions(): void;
    protected getEntityLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectableForm, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProjectableForm, "ng-component", never, { "isModal": { "alias": "isModal"; "required": false; }; "formData": { "alias": "formData"; "required": false; }; "entityId": { "alias": "entityId"; "required": false; }; }, { "close": "close"; "dataChange": "dataChange"; }, never, never, false, never>;
}

declare class TerminatorFormComponent extends ProjectableForm implements OnInit, OnDestroy {
    svc: TerminatorFormService;
    private schemaSvc;
    protected settingsService: SettingsService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    errors: any;
    close: EventEmitter<void>;
    formView: string;
    options: any[];
    isEditing: boolean;
    formDataInvalid: boolean;
    editMode: boolean;
    items: any;
    settings: any;
    selectedIdentityNamedAttribute: any;
    selectedServiceNamedAttribute: any;
    selectedRouterNamedAttribute: any;
    selectedIdentityId: any;
    selectedServiceId: any;
    selectedRouterId: any;
    entityType: string;
    entityClass: typeof Terminator;
    constructor(svc: TerminatorFormService, schemaSvc: SchemaService, growlerService: GrowlerService, extService: ExtensionService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, route: ActivatedRoute, location: Location);
    ngOnInit(): void;
    protected entityUpdated(): void;
    ngOnDestroy(): void;
    headerActionRequested(event: any): void;
    multiActionRequested(action: any): void;
    clear(): void;
    clearForm(): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: any;
    set apiData(data: any);
    dataChanged(event: any): void;
    initSelectedAttributes(): void;
    serviceAttributeChanged(event?: any): void;
    identityAttributeChanged(event?: any): void;
    routerAttributeChanged(event?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TerminatorFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TerminatorFormComponent, "lib-configuration", never, { "errors": { "alias": "errors"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class CsvDownloadService {
    private growler;
    constructor(growler: GrowlerService);
    download(filename: string, items: any[], columns: any[], translateStatus?: boolean, isEndpoint?: boolean, options?: any, toUpperCase?: boolean): void;
    downloadAll(data: any, filename: any, useOptions?: any, type?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CsvDownloadService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CsvDownloadService>;
}

declare class TableColumnDefaultComponent implements IHeaderAngularComp, AfterViewInit, OnInit {
    private filterService;
    item: {
        selected: boolean;
    };
    headerParams: any;
    headerName: any;
    enableSorting: any;
    sortDir: any;
    sortCol: any;
    columnObj: any;
    columnDef: any;
    filterType: string;
    filterOptions: any[];
    columnFilters: any;
    filtering: boolean;
    pinned: any;
    showFilter: boolean;
    comboActive: boolean;
    showSecondaryFilter: boolean;
    _showColumnMenu: any;
    onlineStatusFilter: any;
    showBubble: boolean;
    showLoader: boolean;
    private subscription;
    menuButton: ElementRef;
    constructor(filterService: DataTableFilterService);
    _statusClass: string;
    get statusClass(): string;
    get filterApplied(): boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    agInit(headerParams?: any): void;
    ngAfterViewInit(): void;
    pin(): void;
    hide(): void;
    sort(event: any): void;
    toggleFilter(event: any): void;
    toggleSecondaryFilter(event: any): void;
    hideFilter(event: any): void;
    refresh(params: IHeaderParams): boolean;
    openGridMenu(): void;
    updateFilterOptions(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnDefaultComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnDefaultComponent, "app-table-column-default", never, {}, {}, never, never, false, never>;
}

declare abstract class ListPageServiceClass {
    protected settings: SettingsServiceClass;
    protected filterService: DataTableFilterService;
    protected csvDownloadService: CsvDownloadService;
    protected extensionService: ExtensionService;
    protected router?: Router;
    abstract initTableColumns(): any[];
    abstract getData(filters?: FilterObj[], sort?: any, page?: any): Promise<any[]>;
    abstract openUpdate(entity?: any): any;
    abstract resourceType: string;
    CSV_COLUMNS: {
        label: string;
        path: string;
    }[];
    basePath: string;
    headerComponentParams: {
        filterType: string;
        enableSorting: boolean;
    };
    ID_COLUMN_DEF: {
        colId: string;
        field: string;
        headerName: string;
        headerComponent: typeof TableColumnDefaultComponent;
        headerComponentParams: {
            filterType: string;
            enableSorting: boolean;
        };
        cellRendererParams: {
            pathRoot: string;
            showIdentityIcons: boolean;
        };
        onCellClicked: (data: {
            data: {
                id: string;
            };
        }) => void;
        resizable: boolean;
        cellClass: string;
        sortable: boolean;
        filter: boolean;
        hide: boolean;
    };
    DEFAULT_PAGING: any;
    totalCount: number;
    dataService: ZitiDataService;
    protected readonly managementPermissions: ManagementPermissionsService;
    refreshData: (sort?: {
        sortBy: string;
        ordering: string;
    }) => void | undefined;
    selectedEntityId: String;
    menuItems: any;
    tableHeaderActions: any;
    /** Original menus/header actions before permission filtering (for singleton page services). */
    private menuItemsBaseline;
    private tableHeaderActionsBaseline;
    private menuTemplateSnapshot;
    private tableHeaderActionsSnapshot;
    currentSettings: any;
    dialogRef: any;
    sideModalOpen: boolean;
    currentSort: {
        sortBy: string;
        ordering: string;
    };
    nameColumnRenderer: (row: {
        data: {
            id: any;
            name: any;
        };
    }) => string;
    rolesRenderer: (row: {
        column: {
            colId: any;
        };
        data: {
            [x: string]: any[];
        };
    }) => string;
    createdAtFormatter: (row: {
        data: {
            createdAt: moment.MomentInput;
        };
    }) => string;
    constructor(settings: SettingsServiceClass, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extensionService: ExtensionService, router?: Router);
    /**
     * Root-provided page services survive route changes; restore baseline menus before each table init
     * so permission filtering does not stack on already-filtered items.
     */
    resetMenusForInit(): void;
    initMenuActions(): void;
    addListItemExtensionActions(row: {
        actionList: any[];
    }): void;
    downloadItems(selectedItems: any[]): void;
    downloadAllItems(): Promise<any>;
    getTableData(resourceType: string, paging: any, filters?: FilterObj[], sort?: any): Promise<any>;
    checkForAssociatedEntities(items: any[], type: string, associatedType: string): Promise<any[]>;
    removeItems(ids: string[]): Promise<any[]>;
    sort(sortBy: any, ordering?: string): void;
    hasSelectedText(): boolean;
    getNetworkJwt(): Promise<any>;
    openEditForm(itemId?: string, basePath?: undefined): void;
    remToPx(remValue: number): number;
    capturePermissionSnapshots(): void;
    rebuildMenusAndHeaders(perm: ManagementPermissionsService): void;
}

type CallbackResults = {
    passed: boolean;
    errors?: any;
};
type ValidatorCallback = (data: any, payload?: any) => Promise<CallbackResults>;
declare class ListPageFormComponent extends ExtendableComponent implements AfterViewInit {
    contentChild: ProjectableForm;
    title: string;
    subTitle: string;
    buttonLabel: string;
    showButtons: boolean;
    formClass: any | undefined;
    validator: ValidatorCallback | undefined;
    close: EventEmitter<void>;
    afterOpen: EventEmitter<void>;
    update: EventEmitter<any>;
    showChange: EventEmitter<boolean>;
    constructor();
    set data(d: any);
    _show: boolean;
    set show(val: boolean);
    onKeydownHandler(event: KeyboardEvent): void;
    ngAfterViewInit(): void;
    closeThisForm(): void;
    openThisForm(): void;
    updateItem(): void;
    updateAndClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListPageFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListPageFormComponent, "lib-list-page-form", never, { "title": { "alias": "title"; "required": false; }; "subTitle": { "alias": "subTitle"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "showButtons": { "alias": "showButtons"; "required": false; }; "formClass": { "alias": "formClass"; "required": false; }; "validator": { "alias": "validator"; "required": false; }; "data": { "alias": "data"; "required": false; }; "show": { "alias": "show"; "required": false; }; }, { "close": "close"; "afterOpen": "afterOpen"; "update": "update"; "showChange": "showChange"; }, ["contentChild"], ["*"], false, never>;
}

declare class ConfigurationsPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    private paging;
    resourceType: string;
    selectedConfig: any;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router);
    initTableColumns(): any;
    _typeHeaderComponentParams: {
        filterType: string;
        enableSorting: boolean;
        filterOptions: {
            label: string;
            value: string;
        }[];
        getFilterOptions: () => {
            label: string;
            value: string;
        }[];
    };
    get typeHeaderComponentParams(): {
        filterType: string;
        enableSorting: boolean;
        filterOptions: {
            label: string;
            value: string;
        }[];
        getFilterOptions: () => {
            label: string;
            value: string;
        }[];
    };
    set typeHeaderComponentParams(params: {
        filterType: string;
        enableSorting: boolean;
        filterOptions: {
            label: string;
            value: string;
        }[];
        getFilterOptions: () => {
            label: string;
            value: string;
        }[];
    });
    getConfigTypes(): Promise<{
        filterType: string;
        enableSorting: boolean;
        filterOptions: {
            label: string;
            value: string;
        }[];
        getFilterOptions: () => {
            label: string;
            value: string;
        }[];
    }>;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    validate: (formData: any, schema: any) => Promise<CallbackResults>;
    validateProperty(key: any, property: any, formData: any, schema: any, parentKey?: any): any;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationsPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationsPageService>;
}

declare const ZITI_TAB_OVERRIDES: InjectionToken<string>;
interface TabInterceptorService {
    override(key: string, tabs: any[]): any[];
}
declare class NoopTabInterceptorService implements TabInterceptorService {
    override(key: string, tabs: any[]): any[];
}
declare class TabNameService {
    private interceptor;
    private settings;
    pageToTabsMap: Map<string, any[]>;
    constructor(interceptor: TabInterceptorService, settings: SettingsServiceClass);
    getTabs(key: string): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<TabNameService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TabNameService>;
}

declare class ConsoleEventsService {
    refreshData: EventEmitter<any>;
    openSideModal: EventEmitter<any>;
    closeSideModal: EventEmitter<any>;
    constructor();
    enableZACEvents(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConsoleEventsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConsoleEventsService>;
}

declare abstract class ListPageComponent {
    protected filterService: DataTableFilterService;
    svc: ListPageServiceClass;
    protected consoleEvents: ConsoleEventsService;
    protected dialogForm: MatDialog;
    protected extensionService?: ExtensionService;
    abstract title: any;
    abstract tabs: {
        url: string;
        label: string;
    }[];
    abstract headerActionClicked(action: string): void;
    abstract tableAction(event: {
        action: string;
        item: any;
    }): void;
    abstract isLoading: boolean;
    abstract closeModal(event?: any): void;
    startCount: string;
    endCount: string;
    totalCount: string;
    itemsSelected: boolean;
    selectedItems: any[];
    columnDefs: any;
    rowData: any[];
    reservedNames: any[];
    filterApplied: boolean;
    dialogRef: any;
    modalOpen: boolean;
    gridObj: any;
    subscription: Subscription;
    private growlerSvc;
    protected readonly managementPermissions: ManagementPermissionsService;
    get headerBlockCreate(): boolean;
    get headerBlockDelete(): boolean;
    get headerBlockRead(): boolean;
    constructor(filterService: DataTableFilterService, svc: ListPageServiceClass, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extensionService?: ExtensionService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    itemToggled(item: any): void;
    protected syncBulkDownloadHeaderAction(): void;
    updateSelectedItems(toggledItem?: any): void;
    refreshData(sort?: {
        sortBy: string;
        ordering: string;
    }, hardRefresh?: boolean): void;
    protected downloadAllItems(): void;
    protected openBulkDelete(selectedItems: any[], entityTypeLabel?: string): void;
    handleExtensionActions(event: any): boolean;
    gridReady(event: any): void;
    refreshCells(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListPageComponent, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ListPageComponent>;
}

declare class ConfigurationsPageComponent extends ListPageComponent implements OnInit {
    svc: ConfigurationsPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    constructor(svc: ConfigurationsPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    confirmAssociatedDelete(configsWithAssociations: any, selectedItems: any, label: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationsPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigurationsPageComponent, "lib-configurations", never, {}, {}, never, never, false, never>;
}

declare class ConfigTypesPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    private paging;
    resourceType: string;
    selectedConfig: any;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router);
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigTypesPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigTypesPageService>;
}

declare class ConfigTypesPageComponent extends ListPageComponent implements OnInit {
    svc: ConfigTypesPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    reservedNames: string[];
    constructor(svc: ConfigTypesPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    confirmAssociatedDelete(configsWithAssociations: any, selectedItems: any, label: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigTypesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigTypesPageComponent, "lib-configurations", never, {}, {}, never, never, false, never>;
}

declare class ConfigType {
    name: string;
    id: string;
    schema: {};
    tags: any;
}

declare class ConfigTypeFormService {
    private dataService;
    private extService;
    private schemaSvc;
    private growlerService;
    private validationService;
    private configTypes;
    items: any[];
    errors: any[];
    saveDisabled: boolean;
    configJsonView: boolean;
    configDataLabel: string;
    constructor(dataService: ZitiDataService, extService: ExtensionService, schemaSvc: SchemaService, growlerService: GrowlerService, validationService: ValidationService);
    getSchema(schemaType: string): Promise<any>;
    save(formData: any): any;
    getConfigTypeDataModel(formData: any, isUpdate: any): ConfigType;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigTypeFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigTypeFormService>;
}

declare class ConfigEditorComponent implements OnInit, AfterViewInit {
    private schemaSvc;
    private growlerService;
    configDataInit: boolean;
    items: any[];
    lColorArray: string[];
    bColorArray: string[];
    hideConfigJSON: boolean;
    /** When true, block edits to embedded config form and JSON editor (e.g. global admin_readonly). */
    readOnly: boolean;
    configErrors: any;
    configErrorsChange: EventEmitter<any>;
    _configData: any;
    set configData(data: any);
    configDataChange: EventEmitter<any>;
    get configData(): any;
    _showJsonView: boolean;
    set showJsonView(showJsonView: boolean);
    get showJsonView(): boolean;
    _schema: boolean;
    set schema(schema: any);
    get schema(): any;
    formDataChangedDebounced: any;
    jsonDataChangedDebounced: any;
    dynamicForm: ViewContainerRef;
    editor: JsonEditorComponent;
    constructor(schemaSvc: SchemaService, growlerService: GrowlerService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    createForm(): void;
    clearForm(): void;
    renderSchema(schema: any): void;
    updateConfigData(): void;
    updateFormView(items: any, data?: any): any;
    getConfigDataFromForm(): void;
    addItemsToConfig(items: any, data?: any, parentType?: string): any;
    validateConfig(schema?: any, showGrowler?: boolean): boolean;
    buildPropertyValidationMap(validationErrors: any, propertyValidationMap: any): void;
    validateConfigItems(items: any, parentType?: string, path?: string, validationErrors?: any[]): boolean;
    displayConfigErrors(propertyValidationMap: any): void;
    initFormData(): void;
    formDataChanged(): void;
    jsonDataChanged(event: any): void;
    removeUndefinedProperties(data: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigEditorComponent, "lib-config-editor", never, { "readOnly": { "alias": "readOnly"; "required": false; }; "configErrors": { "alias": "configErrors"; "required": false; }; "configData": { "alias": "configData"; "required": false; }; "showJsonView": { "alias": "showJsonView"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; }, { "configErrorsChange": "configErrorsChange"; "configDataChange": "configDataChange"; }, never, never, false, never>;
}

declare class ConfigTypeFormComponent extends ProjectableForm implements OnInit, OnDestroy {
    svc: ConfigTypeFormService;
    private schemaSvc;
    protected settingsService: SettingsService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    private validationService;
    errors: any;
    close: EventEmitter<void>;
    options: any[];
    isEditing: boolean;
    formView: string;
    formDataInvalid: boolean;
    editMode: boolean;
    items: any;
    selectedSchema: any;
    associatedServices: any[];
    associatedServiceNames: any[];
    servicesLoading: boolean;
    settings: any;
    selectedConfigTypeId: string;
    entityType: string;
    entityClass: typeof ConfigType;
    configEditor: ConfigEditorComponent;
    constructor(svc: ConfigTypeFormService, schemaSvc: SchemaService, growlerService: GrowlerService, extService: ExtensionService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, route: ActivatedRoute, location: Location, validationService: ValidationService, dialogForm: MatDialog);
    ngOnInit(): void;
    entityUpdated(): void;
    ngOnDestroy(): void;
    get configTypeEmpty(): boolean;
    headerActionRequested(event: any): void;
    multiActionRequested(action: any): void;
    apiActionRequested(action: any): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    clear(): void;
    clearForm(): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: any;
    set apiData(data: any);
    dataChanged(event: any): void;
    get saveDisabled(): boolean;
    get saveButtonTooltip(): "" | "Can not edit this system config type";
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigTypeFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigTypeFormComponent, "lib-config-type-form", never, { "errors": { "alias": "errors"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class ListPageHeaderComponent {
    title: string;
    tabs: any[];
    showAdd: boolean;
    hideAction: boolean;
    /** When true, hide the create (+) control even if showAdd is true. */
    blockCreate: boolean;
    /** When true, hide the bulk delete (-) control when rows are selected. */
    blockDelete: boolean;
    actionClicked: EventEmitter<string>;
    clickAction(value: string): void;
    tabSelected(tab: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListPageHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListPageHeaderComponent, "lib-list-page-header", never, { "title": { "alias": "title"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; "showAdd": { "alias": "showAdd"; "required": false; }; "hideAction": { "alias": "hideAction"; "required": false; }; "blockCreate": { "alias": "blockCreate"; "required": false; }; "blockDelete": { "alias": "blockDelete"; "required": false; }; }, { "actionClicked": "actionClicked"; }, never, never, false, never>;
}

declare class FilterBarComponent {
    filterService: DataTableFilterService;
    _filters: any[];
    filterName: string;
    filterColumn: string;
    startCount: string;
    endCount: string;
    totalCount: string;
    currentPage: number;
    filtering: boolean;
    filterString: string;
    inputChangedDebounced: lodash.DebouncedFunc<() => void>;
    constructor(filterService: DataTableFilterService);
    nextPage(): void;
    prevPage(): void;
    get nextDisabled(): boolean;
    get prevDisabled(): boolean;
    inputChanged(): void;
    removeFilter(filterObj: FilterObj): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterBarComponent, "lib-table-filter-bar", never, { "filterName": { "alias": "filterName"; "required": false; }; "filterColumn": { "alias": "filterColumn"; "required": false; }; "startCount": { "alias": "startCount"; "required": false; }; "endCount": { "alias": "endCount"; "required": false; }; "totalCount": { "alias": "totalCount"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; }, {}, never, never, false, never>;
}

declare class IdentitiesPageService extends ListPageServiceClass {
    private zitiService;
    csvDownloadService: CsvDownloadService;
    private growlerService;
    private dialogForm;
    private extService;
    protected router: Router;
    private paging;
    modalType: string;
    CSV_COLUMNS: {
        label: string;
        path: string;
    }[];
    identityRoleAttributes: any[];
    selectedIdentityRoleAttributes: any[];
    selectedIdentity: any;
    columnFilters: any;
    menuItems: {
        name: string;
        action: string;
    }[];
    tableHeaderActions: {
        name: string;
        action: string;
    }[];
    resourceType: string;
    constructor(settings: SettingsServiceClass, filterService: DataTableFilterService, zitiService: ZitiDataService, csvDownloadService: CsvDownloadService, growlerService: GrowlerService, dialogForm: MatDialog, extService: ExtensionService, router: Router);
    validate: (formData: any) => Promise<CallbackResults>;
    initTableColumns(): any;
    getIdentityRoleAttributes(): Promise<any>;
    getData(filters?: FilterObj[], sort?: any, page?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    hasAuthenticator(item: any): any;
    hasEnrolmentToken(item: any): any;
    enrollmentExpired(item: any): boolean;
    getIdentitiesRoleAttributes(): Promise<any>;
    resetMFA(identity: any): Promise<void>;
    getJWT(identity: any): any;
    getToken(identity: any): any;
    downloadJWT(jwt: any, name: any): void;
    copyToken(token: any): void;
    resetJWT(identity: any): any;
    reissueJWT(identity: any): any;
    getEnrollmentExpiration(identity: any): any;
    resetEnrollment(identity: any, date: any): Promise<void>;
    openUpdate(itemId?: any): void;
    openOverridesModal(item: any): void;
    deleteEnrollment(identity: any): Promise<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IdentitiesPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IdentitiesPageService>;
}

declare class IdentitiesPageComponent extends ListPageComponent implements OnInit, OnDestroy {
    svc: IdentitiesPageService;
    private tabNames;
    private router;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    constructor(svc: IdentitiesPageService, filterService: DataTableFilterService, dialogForm: MatDialog, tabNames: TabNameService, router: Router, consoleEvents: ConsoleEventsService, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    closeModal(event?: any): void;
    dataChanged(event: any): void;
    tableAction(event: any): void;
    downloadJWT(item: any): void;
    showQRCode(item: any): void;
    trackMenuAction(action: string, item: any): void;
    deleteItem(item: any): void;
    openIdentityVisualizer(identity: any): void;
    resetEnrollment(identity: any): void;
    reissueEnrollment(identity: any): void;
    ngOnDestroy(): void;
    canDeactivate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IdentitiesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IdentitiesPageComponent, "lib-identities", never, {}, {}, never, ["[slot=list-page-subheader]"], false, never>;
}

declare class EdgeRoutersPageService extends ListPageServiceClass {
    private zitiService;
    csvDownloadService: CsvDownloadService;
    private growlerService;
    private dialogForm;
    private extService;
    protected router: Router;
    private paging;
    modalType: string;
    CSV_COLUMNS: {
        label: string;
        path: string;
    }[];
    selectedEdgeRouter: any;
    columnFilters: any;
    menuItems: {
        name: string;
        action: string;
    }[];
    tableHeaderActions: {
        name: string;
        action: string;
    }[];
    resourceType: string;
    constructor(settings: SettingsServiceClass, filterService: DataTableFilterService, zitiService: ZitiDataService, csvDownloadService: CsvDownloadService, growlerService: GrowlerService, dialogForm: MatDialog, extService: ExtensionService, router: Router);
    validate: (formData: any) => Promise<CallbackResults>;
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any, page?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    hasEnrolmentToken(item: any): boolean;
    getEdgeRouterRoleAttributes(): Promise<any>;
    getJWT(identity: any): any;
    downloadJWT(jwt: any, name: any): void;
    reenroll(router: any): any;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeRoutersPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EdgeRoutersPageService>;
}

declare class EdgeRoutersPageComponent extends ListPageComponent implements OnInit, OnDestroy {
    svc: EdgeRoutersPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    edgeRouterRoleAttributes: any[];
    formDataChanged: boolean;
    constructor(svc: EdgeRoutersPageService, filterService: DataTableFilterService, dialogForm: MatDialog, tabNames: TabNameService, consoleEvents: ConsoleEventsService, extService: ExtensionService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    headerActionClicked(action: string): void;
    closeModal(event?: any): void;
    dataChanged(event: any): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    downloadJWT(item: any): void;
    deleteItem(item: any): void;
    getEdgeRouterRoleAttributes(): void;
    canDeactivate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeRoutersPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EdgeRoutersPageComponent, "lib-edge-routers", never, {}, {}, never, never, false, never>;
}

declare class TransitRoutersPageService extends ListPageServiceClass {
    private zitiService;
    csvDownloadService: CsvDownloadService;
    private growlerService;
    private dialogForm;
    private extService;
    protected router: Router;
    private paging;
    modalType: string;
    CSV_COLUMNS: {
        label: string;
        path: string;
    }[];
    selectedEdgeRouter: any;
    columnFilters: any;
    menuItems: {
        name: string;
        action: string;
    }[];
    tableHeaderActions: {
        name: string;
        action: string;
    }[];
    resourceType: string;
    constructor(settings: SettingsServiceClass, filterService: DataTableFilterService, zitiService: ZitiDataService, csvDownloadService: CsvDownloadService, growlerService: GrowlerService, dialogForm: MatDialog, extService: ExtensionService, router: Router);
    validate: (formData: any) => Promise<CallbackResults>;
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any, page?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    hasEnrolmentToken(item: any): boolean;
    getJWT(identity: any): any;
    downloadJWT(jwt: any, name: any): void;
    reenroll(router: any): any;
    openUpdate(entity?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TransitRoutersPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TransitRoutersPageService>;
}

declare class TransitRoutersPageComponent extends ListPageComponent implements OnInit, OnDestroy {
    svc: TransitRoutersPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    edgeRouterRoleAttributes: any[];
    formDataChanged: boolean;
    constructor(svc: TransitRoutersPageService, filterService: DataTableFilterService, dialogForm: MatDialog, tabNames: TabNameService, consoleEvents: ConsoleEventsService, extService: ExtensionService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    headerActionClicked(action: string): void;
    closeModal(event?: any): void;
    dataChanged(event: any): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    downloadJWT(item: any): void;
    deleteItem(item: any): void;
    canDeactivate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TransitRoutersPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TransitRoutersPageComponent, "lib-edge-routers", never, {}, {}, never, never, false, never>;
}

type ZitiDateRangeQuickOption = {
    id: string;
    label: string;
};
declare class DateRangeQuickHeaderService {
    readonly rangeClick$: Subject<string>;
    readonly selectedRange$: BehaviorSubject<string>;
    readonly options$: BehaviorSubject<ZitiDateRangeQuickOption[]>;
    clickRange(id: string): void;
    setSelectedRange(id: string): void;
    setOptions(options: ZitiDateRangeQuickOption[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeQuickHeaderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DateRangeQuickHeaderService>;
}

declare class DateRangeQuickHeaderComponent implements OnDestroy {
    private calendar;
    private dateAdapter;
    private cdr;
    private headerService;
    selectedRange: string;
    options: ZitiDateRangeQuickOption[];
    private sub;
    constructor(calendar: MatCalendar<Date>, dateAdapter: DateAdapter<Date>, cdr: ChangeDetectorRef, headerService: DateRangeQuickHeaderService);
    get periodLabel(): string;
    previousClicked(): void;
    nextClicked(): void;
    quickRange(id: string): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeQuickHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangeQuickHeaderComponent, "lib-date-range-quick-header", never, {}, {}, never, never, false, never>;
}

declare class TableColumnMenuComponent implements IHeaderAngularComp {
    item: {
        selected: boolean;
        id: string;
        actionList: any[];
    };
    headerParams: any;
    open: boolean;
    agInit(headerParams: IHeaderParams): void;
    refresh(headerParams: IHeaderParams): boolean;
    toggleMenu(event: any): void;
    closeActionMenu(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnMenuComponent, "app-table-column-menu", never, {}, {}, never, never, false, never>;
}

declare class DataTableService {
    tableId: any;
    gridObj: any;
    constructor();
    refreshCells(gridObj: any, rowData: any): void;
    pinColumn(column: any, pinned: any): void;
    resizeGridColumns(event?: {}): void;
    saveColumnState(): void;
    onColumnsResized(column: any): void;
    private saveColumnWidths;
    getRowNodeId(row: any): any;
    resetCookieConfig(): void;
    isServerSideGroup: (dataItem: any) => boolean;
    getServerSideGroupKey: (dataItem: any) => any;
    getDataPath(data: any): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DataTableService>;
}

declare class DataTableComponent implements OnChanges, OnInit {
    svc: DataTableService;
    private tableFilterService;
    private dateHeaderService;
    rowData: any;
    expandRowData: any;
    collapseRowData: any;
    rowValidation: any;
    isTimeSearchAvailable: boolean;
    isLoading: any;
    set tableId(id: string);
    options: {
        noSelect: boolean;
        noMenu: boolean;
    };
    validateService: any;
    rowsToggled: any;
    tableRefreshCount: any;
    set view(value: any);
    serverSideDataSource: any;
    allowDownload: boolean;
    startCount: any;
    endCount: any;
    totalCount: any;
    emptyMsg: any;
    filterApplied: boolean;
    menuItems: any;
    headerActions: any;
    noItemsClass: any;
    entityTypeName: string;
    showNoItemsAdd: boolean;
    /** When true, empty-state copy does not prompt to add (e.g. admin_readonly / no create permission). */
    noItemsReadonly: boolean;
    /** When true, shows "no permission to view" message instead of the table. */
    accessDenied: boolean;
    currentPage: number;
    noItemsImage: string;
    rowHeight: number;
    filterName: string;
    filterColumn: string;
    actionRequested: EventEmitter<{
        action: string;
        item?: any;
    }>;
    gridReady: EventEmitter<any>;
    dragStart: EventEmitter<any>;
    dragLeave: EventEmitter<any>;
    pageChanged: EventEmitter<any>;
    _view: string;
    frameworkComponents: any;
    gridModules: any;
    gridOptions: any;
    visibleColumns: any;
    hiddenColumns: any;
    visibleColumnIds: any;
    hiddenColumnIds: any;
    mergedColumnDefinitions: any;
    openMenu: any;
    openHeaderMenu: any;
    filterOptions: any;
    showFilterOptions: any;
    showDateTimePicker: any;
    /** When true, picker was opened from header filter icon: show only calendar, position at icon */
    datePickerFromHeader: boolean;
    showTagSelector: any;
    appendAttributeHash: boolean;
    attributesColumn: string;
    dateTimeColumn: string;
    dateTimeFilterLabel: string;
    selectedRange: string;
    dateValue: any;
    dateRangeStart: Date | null;
    dateRangeEnd: Date | null;
    menuLeft: any;
    menuTop: any;
    gridRendered: any;
    resizeHandlerInit: boolean;
    resizeGridColumnsDebounced: any;
    selectedItem: any;
    entityTypeLabel: string;
    columnFilters: any;
    roleAttributes: any[];
    namedAttributes: any[];
    selectedRoleAttributes: any[];
    selectedNamedAttributes: any[];
    autoGroupColumnDef: any;
    currentHeaderComponentParams: any;
    subscription: Subscription;
    rangeHeader: typeof DateRangeQuickHeaderComponent;
    private readonly dateRangeLabelMap;
    menuColumnDefinition: {
        colId: string;
        field: string;
        resizable: boolean;
        width: number;
        sortable: boolean;
        lockPosition: boolean;
        suppressMovable: boolean;
        headerClass: string;
        cellClass: string;
        cellRenderer: string;
        cellRendererParams: {
            openMenu: ($event: any, item: any) => void;
            closeMenu: (event: any) => void;
        };
        suppressSizeToFit: boolean;
        pinned: string;
        headerComponent: typeof TableColumnMenuComponent;
        headerComponentParams: {
            openHeaderMenu: ($event: any) => void;
            closeMenu: (event: any) => void;
        };
    };
    private _initialColumnDefs;
    private _refreshCellsDebounced;
    private _onColumnsResizedDebounced;
    private _saveColumnStateDebounced;
    private selectColumnDefinition;
    rangePicker?: MatDateRangePicker<Date>;
    contextMenu: any;
    tableContainer: ElementRef;
    constructor(svc: DataTableService, tableFilterService: DataTableFilterService, dateHeaderService: DateRangeQuickHeaderService);
    hideMenuItem(menuItem: any, selectedItem: any): any;
    private _columnDefinitions;
    set columnDefinitions(value: any);
    get showFilterBar(): boolean;
    set refreshCount(value: number);
    get showTable(): any;
    ngOnInit(): void;
    ngOnChanges(changes: any): void;
    columnVisibilityChanged(event: any): void;
    openActionMenu(event: any, item: any): void;
    onGridReady(params: any): void;
    resetTableColumns(): void;
    openHeaderActionMenu(event: any): void;
    closeActionMenu(): void;
    openHeaderFilter(event: any, options: any, type: any, columnId: any, filterLabel: any, headerComponentParams: any): void;
    setDateRangeFilter(range: any): void;
    get dateRangeDisplayText(): string;
    tagSelectionChanged(event: any, isRole: any): void;
    applyFilter(event: any, filter: any): void;
    closeHeaderFilter(event: any): void;
    closeDateTime(event: any): void;
    onCustomDateRangeStartChanged(date: Date | null): void;
    onCustomDateRangeEndChanged(date: Date | null): void;
    closeTagSelector(event: any): void;
    openCreate(): void;
    anySelected(): boolean;
    showDownload(): boolean;
    _initGridResizeHandler(): void;
    _initGridOptions(): void;
    _validateTable(eventObj: any): void;
    _applyColumnState(): void;
    _addColumnEvents(): void;
    _getCellStyle(params: any): "" | "ziti-table-cell-error";
    updateColumnVisibility(colId: any, visible: any): void;
    updateEntityTypeLabel(): void;
    setColumnVisibilityColumn(column: any, visible: any): void;
    _updateHiddenColumns(): void;
    addHeaderMenu(columnDefs?: any[]): void;
    _addDefaultColumnDefs(): void;
    _storeInitialColumnDefs(): void;
    _initColumnVisibility(): void;
    _updateGridColumns(): void;
    _setColumnWidths(): void;
    _setColumnOrderAndVisibility(): void;
    _handleTableScroll(scroller: any): void;
    remToPx(remValue: any): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DataTableComponent, "lib-data-table", never, { "rowData": { "alias": "rowData"; "required": false; }; "expandRowData": { "alias": "expandRowData"; "required": false; }; "collapseRowData": { "alias": "collapseRowData"; "required": false; }; "rowValidation": { "alias": "rowValidation"; "required": false; }; "isTimeSearchAvailable": { "alias": "isTimeSearchAvailable"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "tableId": { "alias": "tableId"; "required": false; }; "options": { "alias": "options"; "required": false; }; "validateService": { "alias": "validateService"; "required": false; }; "rowsToggled": { "alias": "rowsToggled"; "required": false; }; "tableRefreshCount": { "alias": "tableRefreshCount"; "required": false; }; "view": { "alias": "view"; "required": false; }; "serverSideDataSource": { "alias": "serverSideDataSource"; "required": false; }; "allowDownload": { "alias": "allowDownload"; "required": false; }; "startCount": { "alias": "startCount"; "required": false; }; "endCount": { "alias": "endCount"; "required": false; }; "totalCount": { "alias": "totalCount"; "required": false; }; "emptyMsg": { "alias": "emptyMsg"; "required": false; }; "filterApplied": { "alias": "filterApplied"; "required": false; }; "menuItems": { "alias": "menuItems"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "noItemsClass": { "alias": "noItemsClass"; "required": false; }; "entityTypeName": { "alias": "entityTypeName"; "required": false; }; "showNoItemsAdd": { "alias": "showNoItemsAdd"; "required": false; }; "noItemsReadonly": { "alias": "noItemsReadonly"; "required": false; }; "accessDenied": { "alias": "accessDenied"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "noItemsImage": { "alias": "noItemsImage"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "filterName": { "alias": "filterName"; "required": false; }; "filterColumn": { "alias": "filterColumn"; "required": false; }; "columnDefinitions": { "alias": "columnDefinitions"; "required": false; }; "refreshCount": { "alias": "refreshCount"; "required": false; }; }, { "actionRequested": "actionRequested"; "gridReady": "gridReady"; "dragStart": "dragStart"; "dragLeave": "dragLeave"; "pageChanged": "pageChanged"; }, never, never, false, never>;
}

declare class TableCellSelectComponent implements ICellRendererAngularComp {
    cellParams: any;
    item: any;
    disableToggle: boolean;
    agInit(params: ICellRendererParams): void;
    refresh(params: ICellRendererParams): boolean;
    toggle(item: any): void;
    get tooltip(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellSelectComponent, "app-table-cell-select", never, {}, {}, never, never, false, never>;
}

declare class TableColumnSelectComponent implements IHeaderAngularComp {
    headerParams: any;
    gridApi: any;
    toggleButton: ElementRef;
    agInit(headerParams: IHeaderParams): void;
    refresh(params: IHeaderParams): boolean;
    toggleAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnSelectComponent, "app-table-column-select", never, {}, {}, never, never, false, never>;
}

declare class TableCellMenuComponent implements ICellRendererAngularComp {
    item: any;
    cellParams: any;
    open: boolean;
    get enableCellMenu(): boolean;
    agInit(cellParams: ICellRendererParams): void;
    refresh(cellParams: ICellRendererParams): boolean;
    toggleMenu(event: any): void;
    closeActionMenu(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellMenuComponent, "app-table-cell-menu", never, {}, {}, never, never, false, never>;
}

declare class TableColumnFilterComponent implements OnInit, AfterViewInit, OnDestroy {
    filterService: DataTableFilterService;
    type: string;
    filterString: string;
    filterName: string;
    columnDef: any;
    openStatusMenu: any;
    dateFilter: any;
    subscription: Subscription;
    setFilterDebounced: lodash__default.DebouncedFunc<() => void>;
    filterInput: ElementRef;
    constructor(filterService: DataTableFilterService);
    ngOnInit(): void;
    setFilter(): void;
    ngAfterViewInit(): void;
    statusClicked(event: any): void;
    ngOnDestroy(): void;
    get availableRoleAttributes(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnFilterComponent, "app-table-column-filter", never, { "type": { "alias": "type"; "required": false; }; "filterString": { "alias": "filterString"; "required": false; }; "filterName": { "alias": "filterName"; "required": false; }; "columnDef": { "alias": "columnDef"; "required": false; }; "openStatusMenu": { "alias": "openStatusMenu"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; }, {}, never, never, false, never>;
}

declare class Identity$1 {
    name: string;
    type: string;
    appData: {};
    isAdmin: boolean;
    roleAttributes: any[];
    authPolicyId: string;
    externalId: string;
    defaultHostingCost: number;
    defaultHostingPrecedence: string;
    tags: {};
    enrollment: {
        ott: boolean;
    };
}

declare const IDENTITY_EXTENSION_SERVICE: InjectionToken<any>;
declare class IdentityFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService);
    save(formData: any): Promise<void>;
    getIdentityDataModel(formData: any, isUpdate: any): Identity$1;
    testService(identityId: any, serviceId: any): Promise<string>;
    refreshIdentity(id: any): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IdentityFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IdentityFormService>;
}

declare class IdentityFormComponent extends ProjectableForm implements OnInit, OnChanges, AfterViewInit {
    protected settingsService: SettingsService;
    svc: IdentityFormService;
    identitiesService: IdentitiesPageService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    protected dialogForm: MatDialog;
    identityRoleAttributes: any[];
    close: EventEmitter<any>;
    entityType: string;
    entityClass: typeof Identity$1;
    isEditing: boolean;
    enrollmentExpiration: any;
    expirationDate: string;
    jwt: any;
    jwtExpired: any;
    associatedServicePolicies: any;
    associatedServicePolicyNames: any;
    associatedServices: any;
    associatedServiceNames: any;
    servicesLoading: boolean;
    servicePoliciesLoading: boolean;
    authPolicies: any;
    formView: string;
    enrollmentType: string;
    enrollmentCA: any;
    enrollmentUPDB: string;
    settings: any;
    testResult: string;
    testResultOpen: boolean;
    cas: any[];
    dialogRef: any;
    constructor(settingsService: SettingsService, svc: IdentityFormService, identitiesService: IdentitiesPageService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location, dialogForm: MatDialog);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    entityUpdated(): void;
    updateBadges(): void;
    refreshIdentity(waitForEnrollmentChange?: boolean): void;
    private pollRefreshIdentity;
    initEnrollmentType(): void;
    getIdentityRoleAttributes(): void;
    roleAttributesChanged(roleAttributes: any[]): void;
    getAssociatedServices(): void;
    getAssociatedServicePolicies(): void;
    getCertificateAuthorities(): void;
    getAuthPolicies(): void;
    get hasAuthenticator(): any;
    get hasEnrolmentToken(): any;
    headerActionRequested(action: any): void;
    multiActionRequested(action: any): void;
    updateEnrollment(): void;
    save(event?: any): void;
    validate(identity?: any): boolean;
    get enrollmentTypeTitle(): "CERTIFICATE AUTHORITY" | "UPDB USERNAME";
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: {};
    set apiData(data: any);
    serviceSelected(serviceName: any): void;
    selectedRange: any;
    disableDurationType: string;
    identityDisabled: boolean;
    disableDuration: Date;
    minDate: Date;
    toggleDisableIdentity(): void;
    toggleIsAdmin(): void;
    get identityType(): any;
    set identityType(type: any);
    get entityDisabled(): any;
    get showResetToken(): any;
    updateExpirationDate(): void;
    getJwtExpired(): boolean;
    disableIdentity(): void;
    enableIdentity(): void;
    closeTestResult(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IdentityFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IdentityFormComponent, "lib-identity-form", never, { "identityRoleAttributes": { "alias": "identityRoleAttributes"; "required": false; }; }, { "close": "close"; }, never, ["[slot=tabs-slot]", "[slot=column-1-slot-1]", "[slot=column-1-slot-2]", "[slot=column-2-slot-1]"], false, never>;
}

declare class EdgeRouter {
    name: string;
    roleAttributes: any[];
    appData: {};
    isTunnelerEnabled: boolean;
    noTraversal: boolean;
    cost: number;
    tags: {};
}

declare const EDGE_ROUTER_EXTENSION_SERVICE: InjectionToken<any>;
declare class EdgeRouterFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    private extService;
    associatedIdentities: any;
    associatedIdentityNames: any;
    associatedServices: any;
    associatedServiceNames: any;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService);
    save(formData: any): Promise<any>;
    getEdgeRouterDataModel(formData: any, isUpdate: any): EdgeRouter;
    getAuthPolicies(): Promise<any[]>;
    copyToClipboard(val: any): void;
    getAssociatedServices(id: any): void;
    getAssociatedIdentities(id: any): void;
    refreshRouter(id: any): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeRouterFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EdgeRouterFormService>;
}

type DefaultAppConfig = {
    tunnelerEnabledReadOnly: boolean;
    isOpenZiti?: boolean;
};

declare class EdgeRouterFormComponent extends ProjectableForm implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    protected settingsService: SettingsService;
    svc: EdgeRouterFormService;
    zitiService: ZitiDataService;
    config: DefaultAppConfig;
    protected router: Router;
    protected route: ActivatedRoute;
    edgeRouterRoleAttributes: any[];
    close: EventEmitter<any>;
    entityType: string;
    entityClass: typeof EdgeRouter;
    formView: string;
    isEditing: boolean;
    servicesLoading: boolean;
    identitiesLoading: boolean;
    authPolicies: any;
    settings: any;
    constructor(settingsService: SettingsService, svc: EdgeRouterFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, config: DefaultAppConfig, router: Router, route: ActivatedRoute, location: Location, dialogForm: MatDialog);
    ngOnInit(): void;
    entityUpdated(): void;
    getEdgeRouterRoleAttributes(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    get hasEnrolmentToken(): boolean;
    multiActionRequested(action: any): void;
    headerActionRequested(action: any): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get apiCallURL(): string;
    get apiData(): any;
    refreshEdgeRouter(): void;
    _apiData: {};
    set apiData(data: any);
    toggleTunnelerEnabled(): void;
    toggleNoTraversal(): void;
    clear(): void;
    isTunnelerDisabled(): boolean;
    get tunnelerEnabledReadOnly(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeRouterFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EdgeRouterFormComponent, "lib-edge-router-form", never, { "edgeRouterRoleAttributes": { "alias": "edgeRouterRoleAttributes"; "required": false; }; }, { "close": "close"; }, never, ["[slot=tabs-slot]", "[slot=column-1-slot-1]", "[slot=column-2-slot-1]"], false, never>;
}

declare class TransitRouterFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    private extService;
    associatedIdentities: any;
    associatedIdentityNames: any;
    associatedServices: any;
    associatedServiceNames: any;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService);
    save(formData: any): Promise<any>;
    getEdgeRouterDataModel(formData: any, isUpdate: any): EdgeRouter;
    getAuthPolicies(): Promise<any[]>;
    copyToClipboard(val: any): void;
    getAssociatedServices(id: any): void;
    getAssociatedIdentities(id: any): void;
    refreshRouter(id: any): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TransitRouterFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TransitRouterFormService>;
}

declare class TransitRouterFormComponent extends ProjectableForm implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    protected settingsService: SettingsService;
    svc: TransitRouterFormService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    edgeRouterRoleAttributes: any[];
    close: EventEmitter<any>;
    headerToggle: boolean;
    entityType: string;
    entityClass: typeof EdgeRouter;
    formView: string;
    isEditing: boolean;
    servicesLoading: boolean;
    identitiesLoading: boolean;
    authPolicies: any;
    settings: any;
    constructor(settingsService: SettingsService, svc: TransitRouterFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location);
    ngOnInit(): void;
    entityUpdated(): void;
    getEdgeRouterRoleAttributes(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    get hasEnrolmentToken(): boolean;
    headerActionRequested(action: any): void;
    multiActionRequested(action: any): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get apiCallURL(): string;
    get apiData(): any;
    refreshEdgeRouter(): void;
    _apiData: {};
    set apiData(data: any);
    toggleDisabled(state?: any): void;
    toggleNoTraversal(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TransitRouterFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TransitRouterFormComponent, "lib-transit-router-form", never, { "edgeRouterRoleAttributes": { "alias": "edgeRouterRoleAttributes"; "required": false; }; "headerToggle": { "alias": "headerToggle"; "required": false; }; }, { "close": "close"; }, never, ["[slot=column-1-slot-1]", "[slot=column-2-slot-1]"], false, never>;
}

declare class HiddenColumnsBarComponent {
    hiddenColumns: any;
    columnVisibilityChanged: EventEmitter<any>;
    setColumnVisibilityColumn(column: any, visible: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HiddenColumnsBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HiddenColumnsBarComponent, "lib-table-hidden-columns-bar", never, { "hiddenColumns": { "alias": "hiddenColumns"; "required": false; }; }, { "columnVisibilityChanged": "columnVisibilityChanged"; }, never, never, false, never>;
}

declare class ConfirmComponent {
    private dialogRef;
    data: any;
    dataObj: {
        appendId: string;
        title: string;
        subtitle: string;
        message: string;
        confirmLabel: string;
        confirmLabelAlt: any;
        cancelLabel: string;
        bulletList: any[];
        submessage: string;
        showCancelButton: boolean;
        showCancelLink: boolean;
        showSecondaryConfirm: boolean;
        secondaryConfirmLabel: string;
        secondaryConfirmed: boolean;
        secondaryActionLabel: any;
        secondaryInfoLabel: any;
        secondaryAction: any;
        imageUrl: string;
    };
    constructor(dialogRef: MatDialogRef<ConfirmComponent>, data: any);
    confirm(): void;
    secondaryAction(): void;
    cancel(): void;
    toggleSecondary(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmComponent, "lib-confirm", never, {}, {}, never, never, false, never>;
}

declare class NoItemsComponent implements OnChanges {
    image: string;
    typeName: string;
    isEmpty: boolean;
    hasAdd: boolean;
    hiddenResults: boolean;
    isLoading: boolean;
    readonly: boolean;
    accessDenied: boolean;
    background: any;
    clickEmit: EventEmitter<any>;
    refresh: EventEmitter<any>;
    constructor();
    ngOnChanges(): void;
    iconClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NoItemsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NoItemsComponent, "lib-no-items", never, { "image": { "alias": "image"; "required": false; }; "typeName": { "alias": "typeName"; "required": false; }; "isEmpty": { "alias": "isEmpty"; "required": false; }; "hasAdd": { "alias": "hasAdd"; "required": false; }; "hiddenResults": { "alias": "hiddenResults"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "accessDenied": { "alias": "accessDenied"; "required": false; }; }, { "clickEmit": "clickEmit"; "refresh": "refresh"; }, never, never, false, never>;
}

declare class SideModalComponent implements OnInit {
    private consoleEvents;
    showClose: boolean;
    open: boolean;
    openChange: EventEmitter<boolean>;
    constructor(consoleEvents: ConsoleEventsService);
    ngOnInit(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SideModalComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SideModalComponent, "lib-side-modal", never, { "showClose": { "alias": "showClose"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], false, never>;
}

declare class FormHeaderComponent implements OnChanges {
    data: any;
    badges: any;
    title: string;
    moreActions: any;
    formView: string;
    saveDisabled: boolean;
    saveTooltip: string;
    actionButtonText: string;
    moreActionsText: string;
    showHeaderToggle: boolean;
    showHeaderButton: boolean;
    /** Hide save / more-actions / multi-save and retitle Edit→View for global admin_readonly without write grants. */
    strictReadonlyUi: boolean;
    multiActions: any[];
    formViewChange: EventEmitter<string>;
    actionRequested: EventEmitter<any>;
    multiActionRequested: EventEmitter<any>;
    _saveActions: {
        id: string;
        label: string;
        hidden: boolean;
    }[];
    saveActions: any[];
    showActionsDropDown: boolean;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    get displayTitle(): string;
    get hasMoreActions(): boolean;
    actionClicked(event: any): void;
    requestAction(action: any): void;
    showMoreActions(): void;
    closeActionsMoreActions(): void;
    get hasMultiActions(): boolean;
    get headerBadges(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormHeaderComponent, "lib-form-header", never, { "data": { "alias": "data"; "required": false; }; "badges": { "alias": "badges"; "required": false; }; "title": { "alias": "title"; "required": false; }; "moreActions": { "alias": "moreActions"; "required": false; }; "formView": { "alias": "formView"; "required": false; }; "saveDisabled": { "alias": "saveDisabled"; "required": false; }; "saveTooltip": { "alias": "saveTooltip"; "required": false; }; "actionButtonText": { "alias": "actionButtonText"; "required": false; }; "moreActionsText": { "alias": "moreActionsText"; "required": false; }; "showHeaderToggle": { "alias": "showHeaderToggle"; "required": false; }; "showHeaderButton": { "alias": "showHeaderButton"; "required": false; }; "strictReadonlyUi": { "alias": "strictReadonlyUi"; "required": false; }; "multiActions": { "alias": "multiActions"; "required": false; }; }, { "formViewChange": "formViewChange"; "actionRequested": "actionRequested"; "multiActionRequested": "multiActionRequested"; }, never, never, false, never>;
}

declare class FormFieldContainerComponent {
    title: string;
    title2: any;
    titleIcon: any;
    layout: string;
    helpText: any;
    helpText2: any;
    label: any;
    count: any;
    action: any;
    actionLabel: string;
    class: string;
    contentStyle: any;
    contentClass: any;
    showHeader: any;
    showToggle: boolean;
    headerActions: any[];
    headerToggle: boolean;
    actionRequested: EventEmitter<any>;
    headerToggleChange: EventEmitter<boolean>;
    helpClicked: EventEmitter<void>;
    constructor();
    onHelpClick(): void;
    actionClicked(action: any): void;
    toggleHeader(option?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldContainerComponent, "lib-form-field-container", never, { "title": { "alias": "title"; "required": false; }; "title2": { "alias": "title2"; "required": false; }; "titleIcon": { "alias": "titleIcon"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "helpText": { "alias": "helpText"; "required": false; }; "helpText2": { "alias": "helpText2"; "required": false; }; "label": { "alias": "label"; "required": false; }; "count": { "alias": "count"; "required": false; }; "action": { "alias": "action"; "required": false; }; "actionLabel": { "alias": "actionLabel"; "required": false; }; "class": { "alias": "class"; "required": false; }; "contentStyle": { "alias": "contentStyle"; "required": false; }; "contentClass": { "alias": "contentClass"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "showToggle": { "alias": "showToggle"; "required": false; }; "headerActions": { "alias": "headerActions"; "required": false; }; "headerToggle": { "alias": "headerToggle"; "required": false; }; }, { "actionRequested": "actionRequested"; "headerToggleChange": "headerToggleChange"; "helpClicked": "helpClicked"; }, never, ["*"], false, never>;
}

declare class PreviewListComponent {
    private router;
    label: string;
    clickable: boolean;
    isLoading: boolean;
    allNames: any[];
    items: any[];
    allowRemove: boolean;
    tooltip: string;
    showfilter: boolean;
    localFilter: boolean;
    itemSelected: EventEmitter<string>;
    itemRemoved: EventEmitter<string>;
    filterChanged: EventEmitter<string>;
    previewItems: any[];
    private hideOption;
    filterFor: string;
    constructor(router: Router);
    ngOnInit(): void;
    ngOnChanges(): void;
    setPreviewItems(): void;
    onKeydownEvent(): void;
    sort(): void;
    selected(item: string): void;
    remove(item: any): void;
    linkClicked(event: any, item: any): void;
    getHrefVal(href: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewListComponent, "lib-preview-list", never, { "label": { "alias": "label"; "required": false; }; "clickable": { "alias": "clickable"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "allNames": { "alias": "allNames"; "required": false; }; "items": { "alias": "items"; "required": false; }; "allowRemove": { "alias": "allowRemove"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "showfilter": { "alias": "showfilter"; "required": false; }; "localFilter": { "alias": "localFilter"; "required": false; }; }, { "itemSelected": "itemSelected"; "itemRemoved": "itemRemoved"; "filterChanged": "filterChanged"; }, never, never, false, never>;
}

declare class LoadingIndicatorComponent implements OnInit {
    isLoading: boolean;
    lottieOptions: AnimationOptions | undefined;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingIndicatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingIndicatorComponent, "lib-loading-indicator", never, { "isLoading": { "alias": "isLoading"; "required": false; }; }, {}, never, never, false, never>;
}

declare class FormFieldToggleComponent {
    label: string;
    orientation: string;
    labelOn: string;
    labelOff: string;
    toggleOn: boolean;
    toggleOnChange: EventEmitter<boolean>;
    enterKeyPressed(event: any): void;
    toggleSwitch(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldToggleComponent, "lib-form-field-toggle", never, { "label": { "alias": "label"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "labelOn": { "alias": "labelOn"; "required": false; }; "labelOff": { "alias": "labelOff"; "required": false; }; "toggleOn": { "alias": "toggleOn"; "required": false; }; }, { "toggleOnChange": "toggleOnChange"; }, never, never, false, never>;
}

declare class JsonViewComponent implements AfterViewInit, OnChanges {
    private growlerService;
    data: any;
    schema: any;
    readOnly: boolean;
    jsonInvalid: boolean;
    showCopy: boolean;
    showLineNumbers: boolean;
    dataChange: EventEmitter<any>;
    jsonChange: EventEmitter<any>;
    jsonInvalidChange: EventEmitter<any>;
    onChangeDebounced: any;
    schemaRefs: any;
    content: any;
    editorDiv: ElementRef;
    validator: any;
    private editor;
    private schemaDefinitions;
    oldData: any;
    currentData: any;
    editorInit: boolean;
    constructor(growlerService: GrowlerService);
    ngAfterViewInit(): void;
    initEditor(): void;
    updateEditor(): void;
    watchData(): void;
    onChange(): Promise<void>;
    getData(): any;
    ngOnChanges(changes: SimpleChanges): void;
    validate(newData?: any): any;
    enterKeyPressed(event: any): void;
    jsonChanged(event: any): void;
    copyToClipboad(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JsonViewComponent, "lib-json-view", never, { "data": { "alias": "data"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "jsonInvalid": { "alias": "jsonInvalid"; "required": false; }; "showCopy": { "alias": "showCopy"; "required": false; }; "showLineNumbers": { "alias": "showLineNumbers"; "required": false; }; }, { "dataChange": "dataChange"; "jsonChange": "jsonChange"; "jsonInvalidChange": "jsonInvalidChange"; }, never, never, false, never>;
}

declare class TagSelectorComponent implements AfterViewInit {
    _availableRoleAttributes: any[];
    _availableNamedAttributes: any[];
    placeholder: string;
    disableField: boolean;
    disableCreate: boolean;
    hideOption: string;
    isLoading: boolean;
    errorMessage: string;
    focusOnInit: boolean;
    namedAttributesServerFiltered: boolean;
    addRoleAttribute: EventEmitter<any>;
    addNamedAttribute: EventEmitter<any>;
    roleAttributeRemoved: EventEmitter<any>;
    namedAttributeRemoved: EventEmitter<any>;
    selectedRoleAttributesChange: EventEmitter<any>;
    selectedNamedAttributesChange: EventEmitter<any>;
    filterChange: EventEmitter<any>;
    hideSelect: boolean;
    displayedRoleOptions: any[];
    displayedNamedOptions: any[];
    filterString: string;
    _hashAttributes: {};
    search: ElementRef;
    dropdownWrapper: ElementRef;
    constructor();
    ngAfterViewInit(): void;
    _selectedRoleAttributes: any[];
    set selectedRoleAttributes(attrs: any);
    _selectedNamedAttributes: any[];
    set selectedNamedAttributes(attrs: any);
    _hasError: boolean;
    set hasError(value: boolean);
    set availableRoleAttributes(attrs: any);
    set availableNamedAttributes(attrs: any);
    isSelected(item: any): boolean;
    addSelectedRoleAttribute(item: any): void;
    addSelectedNamedAttribute(item: any): void;
    isAttributeSelected(attribute: any): boolean;
    removeRoleAttribute(item: any): void;
    removeNamedAttribute(item: any): void;
    inputFocus(): void;
    inputFocusOut(): void;
    toggleSelect(): void;
    openSelect(): void;
    hide(): void;
    handleKeyUp($event: KeyboardEvent, filterString: string): void;
    handleKeyDown($event: KeyboardEvent): void;
    applyFilter: () => void;
    applyFilterMouseUp(): void;
    _filterAttributes(): void;
    addNewAttribute(attribute: string): void;
    get isNothingSelected(): boolean;
    nameSort: (a: any, b: any) => 0 | 1 | -1;
    static ɵfac: i0.ɵɵFactoryDeclaration<TagSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TagSelectorComponent, "lib-tag-selector", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disableField": { "alias": "disableField"; "required": false; }; "disableCreate": { "alias": "disableCreate"; "required": false; }; "hideOption": { "alias": "hideOption"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "focusOnInit": { "alias": "focusOnInit"; "required": false; }; "namedAttributesServerFiltered": { "alias": "namedAttributesServerFiltered"; "required": false; }; "selectedRoleAttributes": { "alias": "selectedRoleAttributes"; "required": false; }; "selectedNamedAttributes": { "alias": "selectedNamedAttributes"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "availableRoleAttributes": { "alias": "availableRoleAttributes"; "required": false; }; "availableNamedAttributes": { "alias": "availableNamedAttributes"; "required": false; }; }, { "addRoleAttribute": "addRoleAttribute"; "addNamedAttribute": "addNamedAttribute"; "roleAttributeRemoved": "roleAttributeRemoved"; "namedAttributeRemoved": "namedAttributeRemoved"; "selectedRoleAttributesChange": "selectedRoleAttributesChange"; "selectedNamedAttributesChange": "selectedNamedAttributesChange"; "filterChange": "filterChange"; }, never, never, false, never>;
}

declare class QrCodeComponent implements OnChanges {
    private dialogRef;
    private dialogForm;
    data: any;
    identitiesSvc: IdentitiesPageService;
    edgeRoutersSvc: EdgeRoutersPageService;
    jwt: any;
    token: any;
    expiration: any;
    identity: any;
    type: string;
    authenticators: any;
    qrOnly: boolean;
    canExpand: boolean;
    doRefresh: EventEmitter<boolean>;
    jwtExpired: any;
    expirationDate: any;
    qrCodeSize: number;
    isModal: boolean;
    resettingMFA: boolean;
    mfaReset: boolean;
    showQRCodeComponent: boolean;
    constructor(dialogRef: MatDialogRef<QrCodeComponent>, dialogForm: MatDialog, data: any, identitiesSvc: IdentitiesPageService, edgeRoutersSvc: EdgeRoutersPageService);
    get showQRCode(): boolean;
    get hasJWT(): boolean;
    get showResetToken(): any;
    get showReissueToken(): boolean;
    get showResetMFA(): any;
    get showReenrollToken(): boolean;
    getJwtExpired(): boolean;
    getExpirationDate(): string;
    reissue(): void;
    resetMFA(): void;
    reenroll(): void;
    reset(): void;
    deleteEnrollment(): void;
    expandQRCode(): void;
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<QrCodeComponent, [{ optional: true; }, { optional: true; }, { optional: true; }, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<QrCodeComponent, "lib-qr-code", never, { "jwt": { "alias": "jwt"; "required": false; }; "token": { "alias": "token"; "required": false; }; "expiration": { "alias": "expiration"; "required": false; }; "identity": { "alias": "identity"; "required": false; }; "type": { "alias": "type"; "required": false; }; "authenticators": { "alias": "authenticators"; "required": false; }; "qrOnly": { "alias": "qrOnly"; "required": false; }; "canExpand": { "alias": "canExpand"; "required": false; }; }, { "doRefresh": "doRefresh"; }, never, never, false, never>;
}

declare class TableCellTokenComponent implements ICellRendererAngularComp {
    dialogForm: MatDialog;
    cellParams: any;
    item: any;
    dialogRef: any;
    constructor(dialogForm: MatDialog);
    agInit(params: ICellRendererParams): void;
    get tokenExpired(): boolean;
    get hasEnrolmentToken(): any;
    getJWT(item: any): any;
    getEnrollmentExpiration(item: any): any;
    downloadCert(): void;
    showQRCode(): void;
    refresh(params: ICellRendererParams<any>): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellTokenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellTokenComponent, "lib-table-cell-token", never, {}, {}, never, never, false, never>;
}

declare class OSTooltipComponent implements ITooltipAngularComp {
    private params;
    data: any;
    infoObj: any;
    color: string;
    agInit(params: {
        color: string;
    } & ITooltipParams): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OSTooltipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OSTooltipComponent, "lib-os-tooltip", never, {}, {}, never, never, false, never>;
}

declare class SDKTooltipComponent implements ITooltipAngularComp {
    private params;
    data: any;
    color: string;
    agInit(params: {
        color: string;
    } & ITooltipParams): void;
    get hasData(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SDKTooltipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SDKTooltipComponent, "lib-sdk-tooltip", never, {}, {}, never, never, false, never>;
}

declare class OverridesService {
    private zitiDataService;
    private growlerService;
    overrides: any;
    constructor(zitiDataService: ZitiDataService, growlerService: GrowlerService);
    loadOverrides(identity: any): Promise<any>;
    loadServices(filter: any): Promise<any>;
    loadConfigs(filter: any): Promise<any>;
    addOverride(identity: any, selectedServiceId: any, selectedConfigId: any): Promise<any>;
    overrideExists(selectedServiceId: any, selectedConfigId: any): boolean;
    removeOverride(identity: any, override: any): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverridesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OverridesService>;
}

declare class FilterSelectOptionTemplateDirective {
    templateRef: TemplateRef<any>;
    constructor(templateRef: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSelectOptionTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FilterSelectOptionTemplateDirective, "ng-template[libFilterSelectOption]", never, {}, {}, never, never, false, never>;
}
declare class FilterSelectTriggerTemplateDirective {
    templateRef: TemplateRef<any>;
    constructor(templateRef: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSelectTriggerTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<FilterSelectTriggerTemplateDirective, "ng-template[libFilterSelectTrigger]", never, {}, {}, never, never, false, never>;
}

declare class FilterSelectComponent implements ControlValueAccessor, OnDestroy {
    id?: string;
    placeholder: string;
    /**
     * Classes applied to the Material select overlay panel (useful for per-instance styling).
     * Note: the panel is rendered in an overlay container, outside this component's DOM.
     */
    panelClass?: string | string[];
    /** Array of raw option objects */
    options: any[];
    /** Property name to use for labels/values when options are objects */
    optionLabel: string;
    optionValue: string;
    /** Show a search input inside the dropdown panel */
    searchable: boolean;
    searchPlaceholder: string;
    /**
     * If true, filters `options` locally. If false, emits `filterChange` so the parent can do remote filtering.
     */
    localFilter: boolean;
    /** If true, opening the control via keyboard focus will auto-open the panel (matches prior p-select UX) */
    openOnFocus: boolean;
    /** Show a clear (X) button to clear the current selection */
    showClear: boolean;
    /** Emits when selection changes */
    selectionChange: EventEmitter<any>;
    /** Emits (debounced) as the user types in the search box */
    filterChange: EventEmitter<string>;
    matSelect?: MatSelect;
    optionTemplate?: FilterSelectOptionTemplateDirective;
    triggerTemplate?: FilterSelectTriggerTemplateDirective;
    /** Combined with ControlValueAccessor disabled state (e.g. disable mat-select when parent form is read-only). */
    disableControl: boolean;
    value: any;
    disabled: boolean;
    filterText: string;
    /** Ensure our overlay panel always carries a stable class for global styling. */
    get resolvedPanelClass(): string[];
    private readonly destroyed$;
    private readonly filterText$;
    private onChange;
    private onTouched;
    constructor();
    ngOnDestroy(): void;
    writeValue(value: any): void;
    registerOnChange(fn: (value: any) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    show(): void;
    hide(): void;
    clear(evt?: Event): void;
    /**
     * Clears the search text. By default does NOT emit `filterChange` (callers can reload explicitly).
     */
    resetFilter(emit?: boolean): void;
    handleFocus(): void;
    onMatSelectionChange(nextValue: any): void;
    onFilterTextChanged(text: string): void;
    clearFilter(evt: Event): void;
    get displayedOptions(): any[];
    get selectedOption(): any;
    get isValueEmpty(): boolean;
    getOptionLabel(option: any): any;
    getOptionValue(option: any): any;
    get selectDisabled(): boolean;
    trackByOption: (_: number, option: any) => any;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSelectComponent, "lib-filter-select", never, { "id": { "alias": "id"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionLabel": { "alias": "optionLabel"; "required": false; }; "optionValue": { "alias": "optionValue"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "localFilter": { "alias": "localFilter"; "required": false; }; "openOnFocus": { "alias": "openOnFocus"; "required": false; }; "showClear": { "alias": "showClear"; "required": false; }; "disableControl": { "alias": "disableControl"; "required": false; }; }, { "selectionChange": "selectionChange"; "filterChange": "filterChange"; }, ["optionTemplate", "triggerTemplate"], never, false, never>;
}

declare class OverridesComponent implements OnInit {
    svc: OverridesService;
    identity: any;
    close: EventEmitter<any>;
    services: any;
    configs: any;
    overrides: any;
    selectedServiceId: any;
    selectedConfigId: any;
    showMore: boolean;
    filterServicesDebounced: lodash.DebouncedFunc<(filterText: string) => void>;
    filterConfigsDebounced: lodash.DebouncedFunc<(filterText: string) => void>;
    servicesList: FilterSelectComponent;
    configList: FilterSelectComponent;
    constructor(svc: OverridesService);
    ngOnInit(): void;
    getServices(filter?: string): void;
    getConfigs(filter?: string): void;
    loadOverrides(): void;
    addOverride(): void;
    removeOverride(override: any): void;
    get disableAddButton(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverridesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OverridesComponent, "lib-overrides", never, { "identity": { "alias": "identity"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class ResetEnrollmentService {
    private growlerService;
    private dataService;
    constructor(growlerService: GrowlerService, dataService: ZitiDataService);
    resetEnrollment(identity: any, dateVal: any): Promise<boolean>;
    reissueEnrollment(identity: any, dateVal: any): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetEnrollmentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResetEnrollmentService>;
}

declare class ResetEnrollmentComponent implements OnInit {
    private svc;
    private dialogRef;
    data: any;
    private dataService;
    minDate: Date;
    type: string;
    identity: any;
    dateValue: Date;
    isSubmitting: boolean;
    constructor(svc: ResetEnrollmentService, dialogRef: MatDialogRef<ResetEnrollmentComponent>, data: any, dataService: ZitiDataService);
    ngOnInit(): void;
    confirm(): void;
    cancel(): void;
    handleAction(): void;
    reset(): void;
    reissue(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResetEnrollmentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResetEnrollmentComponent, "lib-reset-enrollment", never, {}, {}, never, never, false, never>;
}

declare class IdentityServicePathHelper {
    posy_for_group3: number;
    constructor();
    getEndpointGraphObj(endpoint: any, bindIdnetities: any, edgerouters: any, selectedServiceOb: any, serviceConfigs: any, filterText?: string, hostEdgeRouters?: any[], fabricRouters?: any[], routerTypesMap?: Map<string, string>, fabricLinks?: any[], serviceCircuits?: any[], serviceTerminators?: any[], fabricApiAvailable?: boolean, availableWidth?: number): RootJson;
    /**
     * Fallback: builds the graph using the original policy-derived approach
     * when fabric API data is not available.
     */
    private buildLegacyGraph;
    static ɵfac: i0.ɵɵFactoryDeclaration<IdentityServicePathHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IdentityServicePathHelper>;
}
declare class RootJson {
    nodes: any;
    links: any;
    addNode(newObject: any): void;
    replaceNode(newObject: any): void;
    addLink(newObject: any): void;
}

interface RouterFetchResult {
    routers: any[];
    routerTypes: Map<string, string>;
}
declare class MapDataService {
    private zitiDataService;
    constructor(zitiDataService: ZitiDataService);
    /**
     * Fetch routers from both fabric and edge APIs, merge them together
     * Returns the merged routers and a map of router types (edge-router vs transit-router)
     */
    fetchRouters(): Promise<RouterFetchResult>;
    /**
     * Fetch identities with optional filters
     */
    fetchIdentities(filters?: any[]): Promise<any[]>;
    /**
     * Fetch services with optional filters
     */
    fetchServices(filters?: any[]): Promise<any[]>;
    /**
     * Fetch circuits from fabric API
     */
    fetchCircuits(): Promise<any[]>;
    /**
     * Fetch terminators from Edge API
     */
    fetchTerminators(): Promise<any[]>;
    /**
     * Fetch links from fabric API
     */
    fetchLinks(): Promise<any[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapDataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MapDataService>;
}

declare class IdentityServicePathComponent implements OnInit {
    private identityServicePathHelper;
    private mapDataService;
    settingsService: SettingsService;
    private zitiService;
    private router;
    private dialogRef;
    data: any;
    d3: any;
    isDarkMode: boolean;
    refreshRotate: boolean;
    closeRotate: boolean;
    private lastRenderContext;
    private zoomBehavior;
    private hasInitialFit;
    private readonly viewBoxWidth;
    private readonly viewBoxHeight;
    filterText: string;
    noSearchResults: boolean;
    autocompleteOptions: any[];
    fullScreen: boolean;
    legendCollapsed: boolean;
    serviceOptions: any;
    endpointData: any;
    networkGraph: any;
    graphJsonObj: any;
    services: any;
    edgerouters: any;
    endpoints: any[];
    selectedService: string;
    serviceSelectError: any;
    doEndpointHasAppwans: boolean;
    doEndpointHasPublicRouters: boolean;
    doEndpointHasServicesInPrivateNw: boolean;
    isLoading: boolean;
    countGrp2Nds: number;
    countGrp3Nds: number;
    allRouters: any[];
    routerTypesMap: Map<string, string>;
    allLinks: any[];
    allCircuits: any[];
    allTerminators: any[];
    fabricApiAvailable: boolean;
    constructor(identityServicePathHelper: IdentityServicePathHelper, mapDataService: MapDataService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, dialogRef: MatDialogRef<IdentityServicePathComponent>, data: any);
    ngOnInit(): void;
    getEndpointNetworkAsCode(): void;
    filterSearchArray(): void;
    clearSearchFilter(): void;
    autocompleteSearch(event: any): void;
    serviceChanged(): void;
    refreshFabricData(): Promise<void>;
    addItemToArray(bindIdnetities: any, ob: any): any;
    getLinkForResource(ob: any, resource: any): any;
    startVisProcess(bindIdnetities: any, selectedServiceOb: any, serviceConfigs: any, hostEdgeRouters?: any[], serviceTerminators?: any[], serviceCircuits?: any[]): void;
    toggleModalSize(): void;
    hide(): void;
    initTopoView(): void;
    fitToContent(): void;
    zoomIn(): void;
    zoomOut(): void;
    resetView(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IdentityServicePathComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IdentityServicePathComponent, "app-identity-visualizer", never, {}, {}, never, never, false, never>;
}

declare abstract class VisualizerServiceClass {
    abstract title: any;
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisualizerServiceClass, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VisualizerServiceClass>;
}

declare class Identity {
    id: any;
    uuid: any;
    name: any;
    status: any;
    type: any;
    rootNode: any;
    serverEgressProtocol: any;
    serverEgressHost: any;
    serverEgressPort: any;
    postureChecks: any;
    events: any;
    os: any;
    utilization: any;
    children: any;
    contextMenu: any;
    online: any;
    osVersion: any;
    createdAt: any;
    updatedAt: any;
    constructor();
}
declare class Service$1 {
    id: any;
    uuid: any;
    name: any;
    intercept_host: any;
    intercept_port: any;
    encrypted: any;
    rootNode: any;
    serverEgressHost: any;
    serverEgressPort: any;
    status: any;
    protocol: any;
    type: any;
    children: any;
    attributes: any;
    utilization: any;
    contextMenu: any;
    createdAt: any;
    updatedAt: any;
    intercept: any;
    constructor();
}
declare class Group {
    id: any;
    name: any;
    type: any;
    group: any;
    children: any;
    constructor(idv: any, s: any, g: any);
}
declare class ERPolicy {
    id: any;
    uuid: any;
    name: any;
    status: any;
    size: any;
    type: any;
    semantic: any;
    isSystem: any;
    rootNode: any;
    children: any;
    contextMenu: any;
    createdAt: any;
    updatedAt: any;
    data: any;
    constructor();
}
declare class ServiceERPolicy {
    id: any;
    uuid: any;
    name: any;
    status: any;
    size: any;
    type: any;
    rootNode: any;
    children: any;
    contextMenu: any;
    createdAt: any;
    updatedAt: any;
    constructor();
}
declare class ERouter {
    id: any;
    uuid: any;
    name: any;
    verified: any;
    size: any;
    type: any;
    provider: any;
    rootNode: any;
    serverEgressProtocol: any;
    serverEgressHost: any;
    serverEgressPort: any;
    children: any;
    utilization: any;
    contextMenu: any;
    online: any;
    disabled: any;
    version: any;
    tunnelerEnabled: any;
    syncStatus: any;
    createdAt: any;
    updatedAt: any;
    constructor();
}
declare class NetworkVisualizerHelper {
    uniqIId: any;
    createUniqId(): number;
    createEdgeRouterNode(er: any, isRootNode?: string): ERouter;
    createServiceEdgeRouterPolicyNode(rawObj: any, isRootNode?: string): ServiceERPolicy;
    createEdgeRouterPolicyNode(rawObj: any, isRootNode?: string): ERPolicy;
    createServicePolicyNode(rawObj: any, isRootNode?: string): Group;
    createIdentityNode(rawObj: any, isRootNode?: string): Identity;
    createServiceNode(rawObj: any, isRootNode?: string): Service$1;
    getResourceTreeObj(networkName: any, networkStatus: any, services: any, identities: any, servicePolicies: any, edgerouters: any, edgeRouterPolicies: any, serviceEdgeRouterPolicies: any, services_totalCount: any, identities_totalCount: any, edgerouters_totalCount: any, service_policies_totalCount: any, edge_router_policies_totalCount: any, service_router_policies_totalCount: any, uniqId: any, logger: any, ...args: any): {
        id: any;
        name: any;
        lastId: number;
        children: any[];
        contextMenu: string;
        type: string;
        rootNode: string;
        status: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkVisualizerHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NetworkVisualizerHelper>;
}

declare class TreeNodeProcessor {
    uniqId: number;
    getPagingObject(pagesize: any): {
        searchOn: string;
        noSearch: boolean;
        filter: string;
        total: any;
        page: number;
        sort: string;
        order: string;
    };
    processIdentitiesForNodeClick(identityNode: any, networkGraph: any, rawEndpoints: any, uniqId: any, zitiService: any, configs: any): Promise<any[]>;
    createId(): number;
    createServiceNode(sr: any): Service$1;
    arrayObjectCopyRightToLeft(leftArr: any, rightArr: any): any;
    addItemToArray(Idnetities: any, ob: any): any;
    createIdentity(ob: any): Identity;
    getLinkForResource(ob: any, resource: any): any;
    findServicesHostedOnEndpoint(rawEp: any, services: any, servicePolicies: any, zitiService: any): any[];
    getServicesForPolicy(services: any, spOb: any): any[];
    findRawEndpoint(epName: any, endpoints: any): any;
    serviceConfigAlias(configs: any): any[];
    processServicesForNodeClick(serviceNode: any, networkGraph: any, services: any, uniqId: any, zitiService: any): Promise<any[]>;
    processServicePoliciesForNodeClick(policyNode: any, networkGraph: any, servicePolicies: any, uniqId: any, zitiService: any): Promise<any[]>;
    getServicesForAServicePolicy(policyObject: any, zitiService: any, pagesize?: number): Promise<any[]>;
    processEdgeroutersForNodeClick(edgerouterNode: any, networkGraph: any, edgerouters: any, uniqId: any, zitiService: any): Promise<any[]>;
    serviceGrouping(servicesChildren: any, servicestree: any): any;
    processEdgeRouterPoliciesForNodeClick(erPolicyNode: any, networkGraph: any, edgeRouterPolicies: any, uniqId: any, zitiService: any): Promise<any[]>;
    processServiceEdgeRouterPoliciesForNodeClick(serviceErPolicyNode: any, networkGraph: any, serviceEdgeRouterPolicies: any, uniqId: any, zitiService: any): Promise<any[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeProcessor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TreeNodeProcessor>;
}

declare class NetworkVisualizerComponent extends VisualizerServiceClass implements OnInit {
    settingsService: SettingsService;
    private zitiService;
    private httpClient;
    private logger;
    treeNodeProcessor: TreeNodeProcessor;
    topologyHelper: NetworkVisualizerHelper;
    title: string;
    d3: any;
    uniqId: number;
    maxObjectsPerNode: number;
    treetooltip: any;
    fullScreen: boolean;
    isLoading: boolean;
    noSearchResults: boolean;
    services: any[];
    services_totalCount: number;
    all_services_fetched: boolean;
    identities: any[];
    identities_totalCount: number;
    all_identities_fetched: boolean;
    edgerouters: any[];
    edgerouters_totalCount: number;
    all_edgerouters_fetched: boolean;
    service_policies: any[];
    service_policies_totalCount: number;
    all_service_policies_fetched: boolean;
    edge_router_policies: any[];
    edge_router_policies_totalCount: number;
    all_edge_router_policies_fetched: boolean;
    service_router_policies: any[];
    service_router_policies_totalCount: number;
    all_service_router_policies_fetched: boolean;
    configs: any[];
    filerResponseMessage: string;
    baseNetworkGraph: any;
    networkGraph: any;
    currentNetwork: any;
    searchRootNode: any;
    servicePoliciesTreeNodes: any[];
    servicesTreeNodes: any[];
    identitiesTreeNodes: any[];
    edgeroutersTreeNodes: any[];
    erPoliciesTreeNodes: any[];
    serviceEdgeRouterPolicyTreeNodes: any[];
    autocompleteOptions: any;
    resourceTypeError: boolean;
    filterText: string;
    searchWord: string;
    resourceType: string;
    zoom: any;
    svg: any;
    treemap: any;
    nodes: any;
    node: any;
    link: any;
    links: any;
    linkExit: any;
    linkUpdate: any;
    openNodes: any[];
    transform: any;
    nodeUpdate: any;
    nodeExit: any;
    nodeEnter: any;
    contextmenuNode: any;
    circles: any;
    contextmenuNodeType: any;
    simulation: any;
    treeData: any;
    graphtooltip: any;
    searchCache: any;
    allPromises: any[];
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, httpClient: HttpClient, logger: LoggerService, treeNodeProcessor: TreeNodeProcessor, topologyHelper: NetworkVisualizerHelper);
    ngOnInit(): void;
    getPagingObject(pagesize: any): {
        filter: string;
        noSearch: boolean;
        order: string;
        page: number;
        searchOn: string;
        sort: string;
        total: any;
    };
    getNetworkObjects(): Promise<void>;
    fetchIdentities(pagesize: any): Promise<void>;
    fetchServices(pagesize: any): Promise<void>;
    fetchServicePolicies(pagesize: any): Promise<void>;
    fetchEdgeRouters(pagesize: any): Promise<void>;
    findEdgeRouterPolicies(pagesize: any): Promise<void>;
    fetchServiceEdgeRouterPolicies(pagesize: any): Promise<void>;
    fetchConfigs(pagesize: any): Promise<void>;
    readAllObjects(): Promise<void>;
    processFirstNetworkGraph(): void;
    fillAutoCompleteTreeNodes(resourcesArray: any, arr: any, typeName: any): any;
    debounce(func: any, timeout?: number): (...args: any[]) => void;
    nwSearchChange(event: any): void;
    autocompleteSearch(event: any): void;
    resourceTypeChanged(): void;
    searchResourceConditionCheck(searchTxt: any): void;
    searchResourceInTree(searchTxt: any): void;
    isNodeExists(rootNode: any, id: any): any;
    explorePathsForSearchedNodes(targetNodes: any, paths: any, nodeIds: any): any;
    processSearchInPreorder(nodeObj: any, searchTxt: any, targetNodes: any): any;
    clearSearchLinkColors(): void;
    openPaths(paths: any, doReset?: boolean): void;
    resetSearchNode(): void;
    resetTree(clearSearch: any): void;
    expand(d: any): void;
    collapse(): void;
    findModelName(): string;
    searchObjectsUsingApi(): Promise<void>;
    filterSearchArray(): void;
    zoomIn(): void;
    zoomOut(): void;
    clearSearchFilter(): void;
    resetAutoCompleteOptions(): void;
    clearSearchType(): void;
    resetZoom(): void;
    graphCollapse(d: any): void;
    initTopoView(): void;
    updateTree(source: any, doReset?: boolean): void;
    sizeToFit(): void;
    setColor(d: any): "var(--tableText)" | "red";
    ticked(): void;
    isAnObject(o: any): boolean;
    readObjectValues(linkObject: any): string;
    nodeColor(d: any): "#FF0000" | "blue";
    dragstarted(event: any, d: any): void;
    dragged(d: any): void;
    dragended(event: any, d: any): void;
    removeTreeTooltip(): void;
    drawTreeTooltip(event: any, s: any): void;
    readTreeKeyValues(event: any, d: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkVisualizerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NetworkVisualizerComponent, "app-network-visualizer", never, {}, {}, never, never, false, never>;
}

declare class CustomTagsComponent implements OnInit, OnChanges {
    tags: any;
    /** View-only: no add/remove/edit; show name/value as text (e.g. global admin_readonly). */
    readOnly: boolean;
    tagsChange: EventEmitter<any>;
    tagsArray: any;
    newTagName: string;
    newTagValue: string;
    errors: any;
    object: ObjectConstructor;
    newTag: {
        name: string;
        value: string;
        initName: string;
        initVal: string;
        showNewTag: boolean;
        errors: {};
    };
    tagNameChangedDebounced: lodash.DebouncedFunc<(tag: any, event?: any) => void>;
    tagValueChangedDebounced: lodash.DebouncedFunc<(tag: any, event?: any) => void>;
    updateTagsArrayDebounced: lodash.DebouncedFunc<(event?: any) => void>;
    updateTagsObjectDebounced: lodash.DebouncedFunc<(event?: any) => void>;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    updateTagsArray(event?: any): void;
    updateTagsObject(event?: any): void;
    addTag(event?: any): void;
    removeTag(tagName: string): void;
    enterKeyPressed(event: any): void;
    tagNameChanged(tag: any, event?: any): void;
    tagValueChanged(tag: any, event?: any): void;
    validate(event?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomTagsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CustomTagsComponent, "lib-custom-tags", never, { "tags": { "alias": "tags"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; }, { "tagsChange": "tagsChange"; }, never, never, false, never>;
}

declare class ServicePolicy {
    name: string;
    serviceRoles: any[];
    identityRoles: any[];
    postureCheckRoles: any[];
    semantic: string;
    type: string;
    tags: any;
}

declare const SERVICE_POLICY_EXTENSION_SERVICE: InjectionToken<any>;
declare class ServicePolicyFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    private extService;
    associatedIdentities: any;
    associatedIdentityNames: any;
    associatedPostureChecks: any;
    associatedPostureCheckNames: any;
    associatedServices: any;
    associatedServiceNames: any;
    serviceNamedAttributesMap: any;
    identityNamedAttributesMap: any;
    postureNamedAttributesMap: any;
    identityNamedAttributes: any;
    serviceNamedAttributes: any;
    postureNamedAttributes: any;
    serviceRoleAttributes: any;
    identityRoleAttributes: any;
    postureRoleAttributes: any;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService);
    save(formData: any): Promise<any>;
    getAssociatedServicesByRole(id: any): void;
    getAssociatedIdentitiesById(id: any): Promise<void>;
    getAssociatedPostureChecksById(id: any): void;
    getAssociatedServicesByAttribute(roleAttributes: any, namedAttributes: any, semantic?: string): Promise<any>;
    getAssociatedIdentitiesByAttribute(roleAttributes: any, namedAttributes: any, semantic?: string): void;
    getAssociatedPostureChecksByAttribute(roleAttributes: any, namedAttributes: any, semantic?: string): void;
    getServicePolicyDataModel(formData: any, isUpdate: any): ServicePolicy;
    copyToClipboard(val: any): void;
    getSelectedRoles(roleAttributes: any, namedAttributes: any, namedAttributeMap: any): any[];
    getServiceRoleAttributes(): Promise<any>;
    private identityNamedAttributesRequestId;
    getIdentityNamedAttributes(filter?: string): Promise<any>;
    private serviceNamedAttributesRequestId;
    getServiceNamedAttributes(filter?: string): Promise<any>;
    getIdentityRoleAttributes(): Promise<any>;
    private postureNamedAttributesRequestId;
    getPostureNamedAttributes(filter?: string): Promise<any>;
    /**
     * The policy response includes serviceRolesDisplay/identityRolesDisplay/postureCheckRolesDisplay
     * alongside the raw #role/@id arrays, resolving every referenced name for free (no extra
     * request) even when that entity falls outside the paged named-attribute fetch above.
     */
    mergeRolesDisplayIntoMaps(formData: any): void;
    private mergeDisplayIntoMap;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServicePolicyFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServicePolicyFormService>;
}

declare class ServicesPageService extends ListPageServiceClass {
    private zitiService;
    csvDownloadService: CsvDownloadService;
    private growlerService;
    private dialogForm;
    protected extensionService: ExtensionService;
    protected router: Router;
    private servicePolicyService;
    private paging;
    modalType: string;
    CSV_COLUMNS: {
        label: string;
        path: string;
    }[];
    serviceType: string;
    selectedService: any;
    columnFilters: any;
    roleAttributes: any[];
    selectedRoleAttributes: any[];
    menuItems: {
        name: string;
        action: string;
    }[];
    tableHeaderActions: {
        name: string;
        action: string;
    }[];
    resourceType: string;
    basePath: string;
    constructor(settings: SettingsServiceClass, filterService: DataTableFilterService, zitiService: ZitiDataService, csvDownloadService: CsvDownloadService, growlerService: GrowlerService, dialogForm: MatDialog, extensionService: ExtensionService, router: Router, servicePolicyService: ServicePolicyFormService);
    validate: (formData: any) => Promise<CallbackResults>;
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any, page?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    getServiceRoleAttributes(): Promise<any>;
    getIdentityNamedAttributes(): Promise<any>;
    getIdentityRoleAttributes(): Promise<any>;
    openSelection(): void;
    openAdvanced(id?: string): void;
    openUpdate(item?: any): void;
    getAllServicesAndOrphans(selectedItems: any): Promise<{
        selectedItems: any[];
        allItem: {
            name: string;
            id: string;
            associatedConfigs: any[];
            associatedServicePolicies: any[];
        };
    }>;
    isConfigAdded(configToAdd: any, allItem: any): any;
    isServicePolicyAdded(policyToAdd: any, allItem: any): any;
    removeAllServicesAndOrphans(allItems: any): Promise<any[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServicesPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServicesPageService>;
}

declare class ServicesPageComponent extends ListPageComponent implements OnInit, OnDestroy {
    svc: ServicesPageService;
    private tabNames;
    private growlerService;
    private settingsService;
    protected extensionService: ExtensionService;
    serviceType: string;
    formDataChanged: boolean;
    isLoading: boolean;
    tabs: {
        url: string;
        label: string;
    }[];
    title: string;
    confirmData: any;
    version: '';
    constructor(svc: ServicesPageService, filterService: DataTableFilterService, dialogForm: MatDialog, tabNames: TabNameService, consoleEvents: ConsoleEventsService, growlerService: GrowlerService, settingsService: SettingsService, extensionService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    deleteItem(item: any): void;
    dataChanged(event: any): void;
    get showCardList(): boolean;
    closeModal(event?: any): void;
    serviceTypeSelected(event: any): void;
    openBulkDelete(selectedItems: any[], entityTypeLabel?: string): void;
    openPreviewSelections(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServicesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServicesPageComponent, "lib-services", never, {}, {}, never, never, false, never>;
}

declare class Service {
    name: string;
    encryptionRequired: boolean;
    terminatorStrategy: string;
    roleAttributes: any[];
    tags: any;
    configs: any[];
    maxIdleTimeMillis: number;
}

declare const SERVICE_EXTENSION_SERVICE: InjectionToken<any>;
declare class ServiceFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    private extService;
    private schemaSvc;
    private validationService;
    private router;
    paging: {
        filter: string;
        noSearch: boolean;
        order: string;
        page: number;
        searchOn: string;
        sort: string;
        total: number;
    };
    formData: any;
    selectedConfig: any;
    configData: any;
    selectedConfigId: any;
    configs: any;
    configTypes: any;
    filteredConfigs: any;
    configsLoading: boolean;
    showCfgPreviewOption: boolean;
    selectedConfigName: any;
    selectedConfigTypeId: any;
    selectedConfigType: any;
    addedConfigs: any;
    addedTerminatorNames: any;
    addedTerminators: any;
    configJsonView: boolean;
    hideConfigJSON: boolean;
    configErrors: any;
    terminatorErrors: any;
    newConfigName: string;
    terminatorHost: string;
    terminatorPort: string;
    selectedSchema: any;
    items: any;
    routers: any;
    configDataLabel: string;
    attachLabel: string;
    errors: any;
    selectedRouterId: string;
    selectedRouter: any;
    selectedBindingId: string;
    terminatorProtocol: string;
    saveDisabled: boolean;
    associatedConfigs: any;
    associatedConfigsMap: any;
    associatedTerminators: any;
    associatedTerminatorNames: any;
    associatedTerminatorsMap: any;
    associatedTerminatorsTotal: number;
    associatedTerminatorsFilter: string;
    associatedServicePolicies: any;
    associatedServicePolicyNames: any;
    associatedServicePoliciesMap: any;
    associatedServicePoliciesTotal: number;
    associatedServicePoliciesFilter: string;
    associatedConfigsLoading: boolean;
    associatedServicePoliciesLoading: boolean;
    associatedTerminatorsLoading: boolean;
    headerComponentParams: {
        filterType: string;
        enableSorting: boolean;
    };
    lColorArray: string[];
    bColorArray: string[];
    subscription: Subscription;
    configEditor: ConfigEditorComponent;
    getAssociatedServicePoliciesDebounced: lodash.DebouncedFunc<(nameFilter?: any) => void>;
    getAssociatedTerminatorsDebounced: lodash.DebouncedFunc<(nameFilter?: any) => void>;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, schemaSvc: SchemaService, validationService: ValidationService, router: Router);
    resetFormData(): void;
    save(formData: any): Promise<any>;
    getAssociatedServicePolicies(nameFilter?: any): void;
    getAssociatedTerminators(nameFilter?: any): void;
    previewConfig(configName: any, router: any): void;
    previewPolicy(policyName: any, router: any): void;
    previewTerminator(policyName: any, router: any): void;
    addTerminators(serviceId: any): void;
    getServiceDataModel(formData: any, isUpdate: any): Service;
    getConfigTypes(): void;
    getConfigs(filters?: any[], page?: number): Promise<void>;
    getRouters(): void;
    getAssociatedConfigs(nameFilter?: any): void;
    createConfig(configData: any): Promise<any>;
    configTypeChanged(resetData?: any): void;
    updatedAddedConfigs(): void;
    toggleJSONView(): void;
    attachConfig(addedConfigId: any): Promise<void>;
    removeConfig(configToRemove: any): void;
    configChanged(resetData?: boolean): Promise<void>;
    validate(): boolean;
    validateConfig(): boolean;
    get showServicePoliciesFilter(): boolean;
    get showTerminatorsFilter(): boolean;
    _apiData: {};
    set apiData(data: any);
    get apiData(): any;
    openTerminatorEditForm(id: any): void;
    sort(sortBy: any, ordering?: string): void;
    hasSelectedText(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceFormService>;
}

declare class ServiceFormComponent extends ProjectableForm implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    protected settingsService: SettingsService;
    svc: ServiceFormService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    set formData(data: any);
    get formData(): any;
    serviceRoleAttributes: any[];
    close: EventEmitter<any>;
    isEditing: boolean;
    enrollmentExpiration: any;
    jwt: any;
    token: any;
    strategies: {
        id: string;
        label: string;
    }[];
    bindingTypes: {
        id: string;
        name: string;
    }[];
    protocols: {
        id: string;
        name: string;
    }[];
    formView: string;
    formDataInvalid: boolean;
    settings: any;
    configFilterChangedDebounced: any;
    entityType: string;
    entityClass: typeof Service;
    configEditor: ConfigEditorComponent;
    constructor(settingsService: SettingsService, svc: ServiceFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location, dialogForm: MatDialog);
    ngOnInit(): void;
    entityUpdated(): void;
    getServiceRoleAttributes(): void;
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    configChanged($event: any): void;
    configFilterChanged(filterText: string): void;
    configTypeChanged($event: any): void;
    get showConfigData(): boolean;
    get canCreateConfig(): boolean;
    attachConfig(): void;
    captureConfigEnterEvent(event: any): void;
    protected deleteServiceWithOrphans(): Promise<any>;
    protected openPreviewDeletions(): void;
    private getOrphanedEntities;
    private deleteServiceAndOrphans;
    headerActionRequested(action: any): void;
    multiActionRequested(action: any): void;
    save(event?: any): Promise<void>;
    toggleEncryptionRequired(): void;
    get apiCallURL(): string;
    get saveButtonTooltip(): "Service data is invalid. Please update and try again." | "Complete and attach config definition, or remove before saving";
    resetForm(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceFormComponent, "lib-service-form", never, { "formData": { "alias": "formData"; "required": false; }; "serviceRoleAttributes": { "alias": "serviceRoleAttributes"; "required": false; }; }, { "close": "close"; }, never, ["[slot=tabs-slot]"], false, never>;
}

declare class PortRangesComponent {
    private validationService;
    fieldValue: string[];
    fieldValueChanged: EventEmitter<any>;
    errors: any;
    invalid: boolean;
    constructor(validationService: ValidationService);
    getProperties(): {
        key: string;
        value: any[];
    }[];
    setProperties(ranges: any): void;
    onKeyup(event: any): void;
    validateConfig(): void;
    setIsValid(isValid: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PortRangesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PortRangesComponent, "lib-port-ranges", never, { "fieldValue": { "alias": "fieldValue"; "required": false; }; }, { "fieldValueChanged": "fieldValueChanged"; }, never, never, false, never>;
}

declare class ForwardingConfigService {
    private validationService;
    constructor(validationService: ValidationService);
    getProperties(protocol: any, address: any, port: any, forwardProtocol: any, forwardAddress: any, forwardPort: any, allowedProtocols: any, allowedAddresses: any, allowedPortRanges: any): {
        key: string;
        value: any;
    }[];
    validate(allowedPortRanges: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForwardingConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ForwardingConfigService>;
}

declare class ForwardingConfigComponent {
    private svc;
    private validationService;
    protocol: string;
    address: string;
    port: number;
    forwardProtocol: boolean;
    forwardAddress: boolean;
    forwardPort: boolean;
    allowedAddresses: any;
    allowedPortRanges: any;
    allowedProtocols: any;
    protocolChange: EventEmitter<string>;
    addressChange: EventEmitter<string>;
    portChange: EventEmitter<number>;
    forwardProtocolChange: EventEmitter<any>;
    forwardAddressChange: EventEmitter<any>;
    forwardPortChange: EventEmitter<any>;
    allowedAddressesChange: EventEmitter<any>;
    allowedPortRangesChange: EventEmitter<any>;
    allowedProtocolsChange: EventEmitter<any>;
    errors: {};
    papComponent: ProtocolAddressPortInputComponent;
    constructor(svc: ForwardingConfigService, validationService: ValidationService);
    forwardProtocolToggled(event: any): void;
    forwardAddressToggled(event: any): void;
    forwardPortToggled(event: any): void;
    setProperties(data: any): void;
    props: {
        key: string;
        value: any;
    }[];
    getProperties(): {
        key: string;
        value: any;
    }[];
    validateAllowedAddresses(): any;
    validatePortRanges(): any;
    setAllowedPortRanges(ranges: any): void;
    isValid(): boolean;
    setValidationErrors(propertyPath: string, validationErrors: any[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ForwardingConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ForwardingConfigComponent, "lib-forwarding-config", never, { "protocol": { "alias": "protocol"; "required": false; }; "address": { "alias": "address"; "required": false; }; "port": { "alias": "port"; "required": false; }; "forwardProtocol": { "alias": "forwardProtocol"; "required": false; }; "forwardAddress": { "alias": "forwardAddress"; "required": false; }; "forwardPort": { "alias": "forwardPort"; "required": false; }; "allowedAddresses": { "alias": "allowedAddresses"; "required": false; }; "allowedPortRanges": { "alias": "allowedPortRanges"; "required": false; }; "allowedProtocols": { "alias": "allowedProtocols"; "required": false; }; }, { "protocolChange": "protocolChange"; "addressChange": "addressChange"; "portChange": "portChange"; "forwardProtocolChange": "forwardProtocolChange"; "forwardAddressChange": "forwardAddressChange"; "forwardPortChange": "forwardPortChange"; "allowedAddressesChange": "allowedAddressesChange"; "allowedPortRangesChange": "allowedPortRangesChange"; "allowedProtocolsChange": "allowedProtocolsChange"; }, never, never, false, never>;
}

declare class CardListComponent extends ProjectableForm {
    protected settingsService: SettingsService;
    svc: ServiceFormService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    close: EventEmitter<any>;
    selected: EventEmitter<any>;
    constructor(settingsService: SettingsService, svc: ServiceFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location);
    clear(): void;
    save(): void;
    back(): void;
    cardSelected(type: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardListComponent, "lib-card-list", never, {}, { "close": "close"; "selected": "selected"; }, never, never, false, never>;
}

declare class SimpleServiceComponent extends ProjectableForm {
    protected settingsService: SettingsService;
    svc: ServiceFormService;
    zitiService: ZitiDataService;
    protected dialogForm: MatDialog;
    private validationService;
    private servicesPageService;
    protected router: Router;
    protected route: ActivatedRoute;
    serviceRoleAttributes: any[];
    identityRoleAttributes: any[];
    identityNamedAttributes: any[];
    showForm: boolean;
    formView: string;
    controllerDomain: string;
    zitiSessionId: any;
    interceptPort: any;
    hostProtocol: string;
    serviceCliCommand: string;
    interceptConfigCliCommand: string;
    hostConfigCliCommand: string;
    dialPolicyCliCommand: string;
    bindPolicyCliCommand: string;
    serviceApiUrl: string;
    interceptConfigApiUrl: string;
    hostConfigApiUrl: string;
    dialPolicyApiUrl: string;
    bindPolicyApiUrl: string;
    initServiceApiData: {
        name: string;
        roleAttributes: any[];
        configs: any[];
        encryptionRequired: boolean;
    };
    initInterceptConfigApiData: {
        name: string;
        configTypeId: string;
        data: {
            portRanges: any[];
            addresses: any[];
            protocols: string[];
        };
    };
    initHostConfigApiData: {
        name: string;
        configTypeId: string;
        data: {
            address: string;
            port: any;
            forwardProtocol: boolean;
            allowedProtocols: string[];
        };
    };
    initDialPolicyApiData: {
        name: string;
        type: string;
        semantic: string;
        serviceRoles: any[];
        identityRoles: any[];
    };
    initBindPolicyApiData: {
        name: string;
        type: string;
        semantic: string;
        serviceRoles: any[];
        identityRoles: any[];
    };
    serviceApiData: any;
    interceptConfigApiData: any;
    hostConfigApiData: any;
    dialPolicyApiData: any;
    bindPolicyApiData: any;
    dialPolicyNamedAttributes: any[];
    dialPolicyRoleAttributes: any[];
    bindPolicyNamedAttributes: any[];
    bindPolicyRoleAttributes: any[];
    identitiesNameIdMap: {};
    identitiesIdNameMap: {};
    interceptConfigId: any;
    hostConfigId: any;
    serviceId: any;
    sdkOnlyDial: boolean;
    sdkOnlyBind: boolean;
    dialogRef: any;
    interceptIncrement: number;
    hostIncrement: number;
    serviceIncrement: number;
    dialIncrement: number;
    bindIncrement: number;
    serviceDataChange: boolean;
    interceptDataChange: boolean;
    hostDataChange: boolean;
    dialDataChange: boolean;
    bindDataChange: boolean;
    identitiesInit: BehaviorSubject<any>;
    entitiesInit: boolean;
    multiActions: any[];
    entityType: string;
    close: EventEmitter<any>;
    selected: EventEmitter<any>;
    constructor(settingsService: SettingsService, svc: ServiceFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, dialogForm: MatDialog, validationService: ValidationService, servicesPageService: ServicesPageService, router: Router, route: ActivatedRoute, location: Location);
    serviceDataSet: boolean;
    set formData(data: any);
    get formData(): any;
    entityIdInit: boolean;
    set entityId(id: String);
    get entityId(): String;
    get formPermissionSaveDisabled(): boolean;
    get formPermissionSaveTooltip(): string;
    ngOnInit(): void;
    formDataSet: boolean;
    initFormData(): Promise<[void, void]>;
    associatedDataInit: boolean;
    initAssociatedData(): void;
    setInitData(): void;
    getAssociatedConfigs(): Promise<any>;
    getAssocaitedPolicies(): Promise<any>;
    /**
     * Sublist identities query is capped; service-policy detail includes identityRolesDisplay
     * so @-roles resolve to human-readable names even when the identity was not in the page.
     */
    private mergeIdentityRolesDisplayIntoMaps;
    private resolveIdentityNameForRole;
    private mergeSelectedIdentityNamesIntoAvailableList;
    getIdentityNamedAttributes(filter?: any): void;
    checkAllDataInit(): void;
    multiActionRequested(action: any): void;
    headerActionRequested(action: any): void;
    toggleSdkOnlyDial(): void;
    toggleSdkOnlyBind(): void;
    serviceNameChanged(event: any): void;
    interceptPortChanged($event: any): void;
    hostProtocolsChanged($event: any): void;
    save(refresh?: any): Promise<void>;
    markEntityError(summaryData: any, type: string, subtype?: string): void;
    showSummary(): any;
    checkNameConflicts(): Promise<boolean>;
    showConflictWarning(conflictData: any): void;
    saveInterceptConfig(summaryData: any): Promise<any>;
    saveHostConfig(summaryData: any): Promise<any>;
    saveConfig(configApiData: any, // e.g., this.interceptConfigApiData
    incrementer: string, // The name of the incrementer property ('interceptIncrement' or 'hostIncrement')
    configIdProp: string, // The name of the ID property ('interceptConfigId' or 'hostConfigId')
    cliCommandProp: string): Promise<any>;
    saveService(summaryData: any): Promise<void>;
    savePolicy(summaryData: any, type?: string): Promise<void>;
    saveEntity(type: any, data: any): Promise<any>;
    updateEntity(type: any, data: any): Promise<any>;
    validate(): boolean;
    validateServiceName(): void;
    validateInterceptAddress(): void;
    validateInterceptPort(): void;
    validateHostAddress(): void;
    validateHostPort(): void;
    validateDialIdentities(): void;
    validateBindIdentities(): void;
    getServicesApiRequest(): string;
    getInterceptConfigApiRequest(): string;
    getHostConfigApiRequest(): string;
    getDialApiRequest(): string;
    getBindApiRequest(): string;
    initDataModels(): void;
    convertToAdvanced(): void;
    protected deleteServiceWithOrphans(): Promise<any>;
    protected openPreviewDeletions(): void;
    private getOrphanedEntities;
    private deleteServiceAndOrphans;
    checkDataChange(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleServiceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleServiceComponent, "lib-simple-service", never, { "serviceRoleAttributes": { "alias": "serviceRoleAttributes"; "required": false; }; "identityRoleAttributes": { "alias": "identityRoleAttributes"; "required": false; }; "identityNamedAttributes": { "alias": "identityNamedAttributes"; "required": false; }; "formData": { "alias": "formData"; "required": false; }; }, { "close": "close"; "selected": "selected"; }, never, never, false, never>;
}

declare class CardComponent {
    imageUrl: string;
    title: string;
    content: string;
    buttonText: string;
    id: string;
    href: string;
    linkClicked(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "lib-card", never, { "imageUrl": { "alias": "imageUrl"; "required": false; }; "title": { "alias": "title"; "required": false; }; "content": { "alias": "content"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "id": { "alias": "id"; "required": false; }; "href": { "alias": "href"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CreationSummaryDialogComponent {
    private dialogRef;
    data: any;
    private growlerService;
    selectedApiData: string;
    selectedApiUrl: string;
    selectedCliCommand: string;
    selectedEntityType: string;
    selectedEntityName: string;
    isEdit: boolean;
    summaryData: any;
    showAPI: boolean;
    hasError: boolean;
    hideSummaryNextTime: boolean;
    constructor(dialogRef: MatDialogRef<ConfirmComponent>, data: any, growlerService: GrowlerService);
    get hasCreationError(): boolean;
    selectZitiEntity(entity: any, type: any): void;
    toggleAPIView(): void;
    copyCliCommands(): void;
    copyAPIRequests(): void;
    doRetry(entityData: any): void;
    close(): void;
    done(): void;
    confirm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CreationSummaryDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CreationSummaryDialogComponent, "lib-creation-summary-dialog", never, {}, {}, never, never, false, never>;
}

declare class ServicePoliciesPageService extends ListPageServiceClass {
    private zitiService;
    csvDownloadService: CsvDownloadService;
    private growlerService;
    private dialogForm;
    private extService;
    protected router: Router;
    private paging;
    modalType: string;
    serviceType: string;
    selectedServicePolicy: any;
    serviceRoleAttributes: any[];
    serviceNamedAttributes: any[];
    serviceNamedAttributesMap: {};
    selectedServiceRoleAttributes: any[];
    selectedServiceNamedAttributes: any[];
    identityRoleAttributes: any[];
    identityNamedAttributes: any[];
    identityNamedAttributesMap: {};
    selectedIdentityRoleAttributes: any[];
    selectedIdentityNamedAttributes: any[];
    postureRoleAttributes: any[];
    postureNamedAttributes: any[];
    postureNamedAttributesMap: {};
    selectedPostureRoleAttributes: any[];
    selectedPostureNamedAttributes: any[];
    columnFilters: any;
    menuItems: {
        name: string;
        action: string;
    }[];
    tableHeaderActions: {
        name: string;
        action: string;
    }[];
    resourceType: string;
    constructor(settings: SettingsServiceClass, filterService: DataTableFilterService, zitiService: ZitiDataService, csvDownloadService: CsvDownloadService, growlerService: GrowlerService, dialogForm: MatDialog, extService: ExtensionService, router: Router);
    validate: (formData: any) => Promise<CallbackResults>;
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any, page?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    getServiceRoleAttributes(): Promise<any>;
    getIdentityNamedAttributes(): Promise<any>;
    getServiceNamedAttributes(): Promise<any>;
    getIdentityRoleAttributes(): Promise<any>;
    getPostureNamedAttributes(): Promise<any>;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServicePoliciesPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServicePoliciesPageService>;
}

declare class ServicePoliciesPageComponent extends ListPageComponent implements OnInit, OnDestroy {
    svc: ServicePoliciesPageService;
    private tabNames;
    private extService;
    serviceType: string;
    serviceRoleAttributes: any[];
    identityRoleAttributes: any[];
    formDataChanged: boolean;
    isLoading: boolean;
    tabs: {
        url: string;
        label: string;
    }[];
    title: string;
    constructor(svc: ServicePoliciesPageService, filterService: DataTableFilterService, dialogForm: MatDialog, tabNames: TabNameService, consoleEvents: ConsoleEventsService, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    getRoleAttributes(): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    serviceTypeSelected(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServicePoliciesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServicePoliciesPageComponent, "lib-service-policies-page", never, {}, {}, never, never, false, never>;
}

declare class ServicePolicyFormComponent extends ProjectableForm implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    protected settingsService: SettingsService;
    svc: ServicePolicyFormService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    close: EventEmitter<any>;
    selectedServiceRoleAttributes: any[];
    selectedServiceNamedAttributes: any[];
    selectedIdentityRoleAttributes: any[];
    selectedIdentityNamedAttributes: any[];
    selectedPostureRoleAttributes: any[];
    selectedPostureNamedAttributes: any[];
    formView: string;
    isEditing: boolean;
    servicesLoading: boolean;
    identitiesLoading: boolean;
    postureChecksLoading: boolean;
    settings: any;
    entityType: string;
    entityClass: typeof ServicePolicy;
    constructor(settingsService: SettingsService, svc: ServicePolicyFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location, dialogForm: MatDialog);
    ngOnInit(): void;
    getServiceNamedAttributesDebounced: lodash.DebouncedFunc<(filter: string) => Promise<void>>;
    getIdentityNamedAttributesDebounced: lodash.DebouncedFunc<(filter: string) => Promise<void>>;
    getPostureNamedAttributesDebounced: lodash.DebouncedFunc<(filter: string) => Promise<void>>;
    entityUpdated(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Keeps already-selected names visible in each picker's available list even though the
     * underlying fetch only returns a bounded/filtered page.
     */
    mergeSelectedIntoAvailable(): void;
    initSelectedAttributes(): void;
    updateAssociations(): void;
    onServiceAttributesChanged(): void;
    onIdentityAttributesChanged(): void;
    onPolicyTypeChanged(): void;
    onPolicySemanticChanged(): void;
    emitInputChange(type: string): void;
    multiActionRequested(action: any): void;
    headerActionRequested(action: any): void;
    save(event?: any): Promise<void>;
    applySelectedAttributes(): void;
    validate(): boolean;
    apiActionRequested(action: any): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: {};
    set apiData(data: any);
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServicePolicyFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServicePolicyFormComponent, "lib-service-policy-form", never, {}, { "close": "close"; }, never, ["[slot=column-1-slot-1]", "[slot=column-2-slot-1]"], false, never>;
}

declare class EdgeRouterPoliciesPageService extends ListPageServiceClass {
    private zitiService;
    csvDownloadService: CsvDownloadService;
    private growlerService;
    private dialogForm;
    private extService;
    protected router: Router;
    private paging;
    modalType: string;
    serviceType: string;
    selectedEdgeRouterPolicy: any;
    routerRoleAttributes: any[];
    routerNamedAttributes: any[];
    routerNamedAttributesMap: {};
    selectedRouterRoleAttributes: any[];
    selectedRouterNamedAttributes: any[];
    identityRoleAttributes: any[];
    identityNamedAttributes: any[];
    identityNamedAttributesMap: {};
    selectedIdentityRoleAttributes: any[];
    selectedIdentityNamedAttributes: any[];
    postureRoleAttributes: any[];
    postureNamedAttributes: any[];
    postureNamedAttributesMap: {};
    selectedPostureRoleAttributes: any[];
    selectedPostureNamedAttributes: any[];
    columnFilters: any;
    menuItems: {
        name: string;
        action: string;
    }[];
    tableHeaderActions: {
        name: string;
        action: string;
    }[];
    resourceType: string;
    constructor(settings: SettingsServiceClass, filterService: DataTableFilterService, zitiService: ZitiDataService, csvDownloadService: CsvDownloadService, growlerService: GrowlerService, dialogForm: MatDialog, extService: ExtensionService, router: Router);
    validate: (formData: any) => Promise<CallbackResults>;
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any, page?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    getEdgeRouterRoleAttributes(): Promise<any>;
    getIdentityNamedAttributes(): Promise<any>;
    getServiceNamedAttributes(): Promise<any>;
    getIdentityRoleAttributes(): Promise<any>;
    getPostureNamedAttributes(): Promise<any>;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeRouterPoliciesPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EdgeRouterPoliciesPageService>;
}

declare class EdgeRouterPoliciesPageComponent extends ListPageComponent implements OnInit, OnDestroy {
    svc: EdgeRouterPoliciesPageService;
    private tabNames;
    private extService;
    routerRoleAttributes: any[];
    identityRoleAttributes: any[];
    formDataChanged: boolean;
    isLoading: boolean;
    tabs: {
        url: string;
        label: string;
    }[];
    title: string;
    constructor(svc: EdgeRouterPoliciesPageService, filterService: DataTableFilterService, dialogForm: MatDialog, tabNames: TabNameService, consoleEvents: ConsoleEventsService, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    getRoleAttributes(): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    serviceTypeSelected(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeRouterPoliciesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EdgeRouterPoliciesPageComponent, "lib-edge-router-policies-page", never, {}, {}, never, never, false, never>;
}

declare class EdgeRouterPolicy {
    name: string;
    edgeRouterRoles: any[];
    identityRoles: any[];
    semantic: string;
    tags: any;
}

declare const EDGE_ROUTER_POLICY_EXTENSION_SERVICE: InjectionToken<any>;
declare class EdgeRouterPolicyFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    private extService;
    associatedIdentities: any;
    associatedIdentityNames: any;
    associatedEdgeRouters: any;
    associatedEdgeRouterNames: any;
    edgeRouterNamedAttributesMap: any;
    identityNamedAttributesMap: any;
    identityNamedAttributes: any;
    edgeRouterNamedAttributes: any;
    edgeRouterRoleAttributes: any;
    identityRoleAttributes: any;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService);
    save(formData: any): Promise<any>;
    getAssociatedServicesByRole(id: any): void;
    getAssociatedIdentitiesById(id: any): void;
    getAssociatedEdgeRoutersByAttribute(roleAttributes: any, namedAttributes: any, semantic?: string): void;
    getAssociatedIdentitiesByAttribute(roleAttributes: any, namedAttributes: any, semantic?: string): void;
    getEdgeRouterRoleAttributes(): Promise<any>;
    private identityNamedAttributesRequestId;
    getIdentityNamedAttributes(filter?: string): Promise<any>;
    private edgeRouterNamedAttributesRequestId;
    getEdgeRouterNamedAttributes(filter?: string): Promise<any>;
    getIdentityRoleAttributes(): Promise<any>;
    /**
     * The policy response includes edgeRouterRolesDisplay/identityRolesDisplay alongside the
     * raw #role/@id arrays, resolving every referenced name for free (no extra request) even
     * when that entity falls outside the paged named-attribute fetch above.
     */
    mergeRolesDisplayIntoMaps(formData: any): void;
    private mergeDisplayIntoMap;
    getEdgeRouterPolicyDataModel(formData: any, isUpdate: any): EdgeRouterPolicy;
    copyToClipboard(val: any): void;
    getSelectedRoles(roleAttributes: any, namedAttributes: any, namedAttributeMap: any): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeRouterPolicyFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EdgeRouterPolicyFormService>;
}

declare class EdgeRouterPolicyFormComponent extends ProjectableForm implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    protected settingsService: SettingsService;
    svc: EdgeRouterPolicyFormService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    close: EventEmitter<any>;
    selectedEdgeRouterRoleAttributes: any[];
    selectedEdgeRouterNamedAttributes: any[];
    selectedIdentityRoleAttributes: any[];
    selectedIdentityNamedAttributes: any[];
    formView: string;
    isEditing: boolean;
    edgeRoutersLoading: boolean;
    identitiesLoading: boolean;
    postureChecksLoading: boolean;
    settings: any;
    entityType: string;
    entityClass: typeof EdgeRouterPolicy;
    constructor(settingsService: SettingsService, svc: EdgeRouterPolicyFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location, dialogForm: MatDialog);
    ngOnInit(): void;
    entityUpdated(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getEdgeRouterNamedAttributesDebounced: lodash.DebouncedFunc<(filter: string) => Promise<void>>;
    getIdentityNamedAttributesDebounced: lodash.DebouncedFunc<(filter: string) => Promise<void>>;
    loadAttributes(): void;
    /**
     * Keeps already-selected names visible in the picker's available list even though the
     * underlying fetch only returns a bounded/filtered page.
     */
    mergeSelectedIntoAvailable(): void;
    initSelectedAttributes(): void;
    updateAssociations(): void;
    headerActionRequested(action: any): void;
    multiActionRequested(action: any): void;
    save(event?: any): Promise<void>;
    applySelectedAttributes(): void;
    validate(): boolean;
    apiActionRequested(action: any): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: {};
    set apiData(data: any);
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EdgeRouterPolicyFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EdgeRouterPolicyFormComponent, "lib-edge-router-policy-form", never, {}, { "close": "close"; }, never, never, false, never>;
}

declare class MultiActionButtonComponent {
    actions: any[];
    actionRequested: EventEmitter<any>;
    showMoreActions: boolean;
    showMoreActionsMenu(): void;
    closeMoreActionsMenu(): void;
    actionClicked(action: any): void;
    isActionHidden(action: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiActionButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiActionButtonComponent, "lib-multi-action-button", never, { "actions": { "alias": "actions"; "required": false; }; }, { "actionRequested": "actionRequested"; }, never, never, false, never>;
}

declare class TableCellNameComponent implements ICellRendererAngularComp {
    dialogForm: MatDialog;
    private router;
    cellParams: any;
    item: any;
    value: any;
    dialogRef: any;
    constructor(dialogForm: MatDialog, router: Router);
    agInit(params: ICellRendererParams): void;
    refresh(params: ICellRendererParams<any>): boolean;
    get namePrefix(): {
        iconClass?: string;
        tooltip?: string;
    } | null;
    linkClicked(event: any): void;
    get cellText(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableCellNameComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableCellNameComponent, "lib-table-cell-name", never, {}, {}, never, never, false, never>;
}

declare class ServiceEdgeRouterPoliciesPageService extends ListPageServiceClass {
    private zitiService;
    csvDownloadService: CsvDownloadService;
    private growlerService;
    private dialogForm;
    private extService;
    protected router: Router;
    private paging;
    modalType: string;
    serviceType: string;
    selectedEdgeRouterPolicy: any;
    routerRoleAttributes: any[];
    routerNamedAttributes: any[];
    routerNamedAttributesMap: {};
    selectedRouterRoleAttributes: any[];
    selectedRouterNamedAttributes: any[];
    serviceRoleAttributes: any[];
    serviceNamedAttributes: any[];
    serviceNamedAttributesMap: {};
    selectedServiceRoleAttributes: any[];
    selectedServiceNamedAttributes: any[];
    columnFilters: any;
    menuItems: {
        name: string;
        action: string;
    }[];
    tableHeaderActions: {
        name: string;
        action: string;
    }[];
    resourceType: string;
    constructor(settings: SettingsServiceClass, filterService: DataTableFilterService, zitiService: ZitiDataService, csvDownloadService: CsvDownloadService, growlerService: GrowlerService, dialogForm: MatDialog, extService: ExtensionService, router: Router);
    validate: (formData: any) => Promise<CallbackResults>;
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any, page?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    getEdgeRouterRoleAttributes(): Promise<any>;
    getServiceNamedAttributes(): Promise<any>;
    getRouterNamedAttributes(): Promise<any>;
    getServiceRoleAttributes(): Promise<any>;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceEdgeRouterPoliciesPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceEdgeRouterPoliciesPageService>;
}

declare class ServiceEdgeRouterPoliciesPageComponent extends ListPageComponent implements OnInit, OnDestroy {
    svc: ServiceEdgeRouterPoliciesPageService;
    private tabNames;
    private extService;
    routerRoleAttributes: any[];
    serviceRoleAttributes: any[];
    formDataChanged: boolean;
    isLoading: boolean;
    tabs: {
        url: string;
        label: string;
    }[];
    title: string;
    constructor(svc: ServiceEdgeRouterPoliciesPageService, filterService: DataTableFilterService, dialogForm: MatDialog, tabNames: TabNameService, consoleEvents: ConsoleEventsService, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    getRoleAttributes(): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    serviceTypeSelected(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceEdgeRouterPoliciesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceEdgeRouterPoliciesPageComponent, "lib-service-edge-router-policies-page", never, {}, {}, never, never, false, never>;
}

declare class ServiceEdgeRouterPolicy {
    name: string;
    edgeRouterRoles: any[];
    serviceRoles: any[];
    semantic: string;
    tags: any;
}

declare const SERVICE_EDGE_ROUTER_POLICY_EXTENSION_SERVICE: InjectionToken<any>;
declare class ServiceEdgeRouterPolicyFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    private extService;
    associatedServices: any;
    associatedServiceNames: any;
    associatedEdgeRouters: any;
    associatedEdgeRouterNames: any;
    edgeRouterNamedAttributesMap: any;
    serviceNamedAttributesMap: any;
    serviceNamedAttributes: any;
    edgeRouterNamedAttributes: any;
    edgeRouterRoleAttributes: any;
    serviceRoleAttributes: any;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService);
    save(formData: any): Promise<any>;
    getAssociatedEdgeRoutersByAttribute(roleAttributes: any, namedAttributes: any, semantic?: string): void;
    getAssociatedServicesByAttribute(roleAttributes: any, namedAttributes: any, semantic?: string): void;
    getEdgeRouterRoleAttributes(): Promise<any>;
    private serviceNamedAttributesRequestId;
    getServiceNamedAttributes(filter?: string): Promise<any>;
    private edgeRouterNamedAttributesRequestId;
    getEdgeRouterNamedAttributes(filter?: string): Promise<any>;
    getServiceRoleAttributes(): Promise<any>;
    /**
     * The policy response includes edgeRouterRolesDisplay/serviceRolesDisplay alongside the
     * raw #role/@id arrays, resolving every referenced name for free (no extra request) even
     * when that entity falls outside the paged named-attribute fetch above.
     */
    mergeRolesDisplayIntoMaps(formData: any): void;
    private mergeDisplayIntoMap;
    getEdgeRouterPolicyDataModel(formData: any, isUpdate: any): ServiceEdgeRouterPolicy;
    copyToClipboard(val: any): void;
    getSelectedRoles(roleAttributes: any, namedAttributes: any, namedAttributeMap: any): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceEdgeRouterPolicyFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ServiceEdgeRouterPolicyFormService>;
}

declare class ServiceEdgeRouterPolicyFormComponent extends ProjectableForm implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    protected settingsService: SettingsService;
    svc: ServiceEdgeRouterPolicyFormService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    close: EventEmitter<any>;
    selectedEdgeRouterRoleAttributes: any[];
    selectedEdgeRouterNamedAttributes: any[];
    selectedServiceRoleAttributes: any[];
    selectedServiceNamedAttributes: any[];
    formView: string;
    isEditing: boolean;
    edgeRoutersLoading: boolean;
    servicesLoading: boolean;
    settings: any;
    entityType: string;
    entityClass: typeof ServiceEdgeRouterPolicy;
    constructor(settingsService: SettingsService, svc: ServiceEdgeRouterPolicyFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location, dialogForm: MatDialog);
    ngOnInit(): void;
    entityUpdated(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    getEdgeRouterNamedAttributesDebounced: lodash.DebouncedFunc<(filter: string) => Promise<void>>;
    getServiceNamedAttributesDebounced: lodash.DebouncedFunc<(filter: string) => Promise<void>>;
    loadAttributes(): void;
    /**
     * Keeps already-selected names visible in the picker's available list even though the
     * underlying fetch only returns a bounded/filtered page.
     */
    mergeSelectedIntoAvailable(): void;
    initSelectedAttributes(): void;
    headerActionRequested(action: any): void;
    multiActionRequested(action: any): void;
    save(event?: any): Promise<void>;
    applySelectedAttributes(): void;
    validate(): boolean;
    apiActionRequested(action: any): void;
    updateAssociations(): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: {};
    set apiData(data: any);
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ServiceEdgeRouterPolicyFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServiceEdgeRouterPolicyFormComponent, "lib-service-edge-router-policy-form", never, {}, { "close": "close"; }, never, never, false, never>;
}

declare class TerminatorsPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    DEFAULT_PAGING: any;
    private paging;
    resourceType: string;
    selectedConfig: any;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router);
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    validate: (formData: any) => Promise<CallbackResults>;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TerminatorsPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TerminatorsPageService>;
}

declare class TerminatorsPageComponent extends ListPageComponent implements OnInit {
    svc: TerminatorsPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    constructor(svc: TerminatorsPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TerminatorsPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TerminatorsPageComponent, "lib-configurations", never, {}, {}, never, never, false, never>;
}

declare class Config {
    name: string;
    data: {};
    configTypeId: string;
    tags: any;
}

declare class ConfigurationService {
    private dataService;
    private extService;
    private schemaSvc;
    private growlerService;
    private validationService;
    private configTypes;
    items: any[];
    errors: any[];
    saveDisabled: boolean;
    configJsonView: boolean;
    configDataLabel: string;
    constructor(dataService: ZitiDataService, extService: ExtensionService, schemaSvc: SchemaService, growlerService: GrowlerService, validationService: ValidationService);
    getSchema(schemaType: string): Promise<any>;
    getConfigTypes(): Promise<any[]>;
    getAssociatedServices(configId: any): Promise<{
        associatedServices: any;
        associatedServiceNames: any;
    }>;
    toggleJSONView(): void;
    save(formData: any): any;
    getConfigDataModel(formData: any, isUpdate: any): Config;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationService>;
}

declare class ConfigurationFormComponent extends ProjectableForm implements OnInit, OnDestroy {
    svc: ConfigurationService;
    private schemaSvc;
    protected settingsService: SettingsService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    errors: any;
    close: EventEmitter<void>;
    options: any[];
    isEditing: boolean;
    formView: string;
    formDataInvalid: boolean;
    editMode: boolean;
    items: any;
    selectedSchema: any;
    associatedServices: any[];
    associatedServiceNames: any[];
    servicesLoading: boolean;
    settings: any;
    selectedConfigTypeId: string;
    entityType: string;
    entityClass: typeof Config;
    configEditor: ConfigEditorComponent;
    constructor(svc: ConfigurationService, schemaSvc: SchemaService, growlerService: GrowlerService, extService: ExtensionService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, route: ActivatedRoute, location: Location, dialogForm: MatDialog);
    ngOnInit(): void;
    entityUpdated(): void;
    getAssociatedServices(): void;
    ngOnDestroy(): void;
    get configTypeEmpty(): boolean;
    headerActionRequested(event: any): void;
    multiActionRequested(action: any): void;
    apiActionRequested(action: any): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    clear(): void;
    clearForm(): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get saveButtonTooltip(): "Complete and attach config definition, or remove before saving" | "Config data is invalid. Please update and try again.";
    getSchema(): void;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: any;
    set apiData(data: any);
    dataChanged(event: any): void;
    deleteEntity(): void;
    private performDelete;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigurationFormComponent, "lib-configuration", never, { "errors": { "alias": "errors"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class JwtSignersPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    private paging;
    resourceType: string;
    selectedConfig: any;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router);
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    validate: (formData: any) => Promise<CallbackResults>;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JwtSignersPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<JwtSignersPageService>;
}

declare class JwtSignersPageComponent extends ListPageComponent implements OnInit {
    svc: JwtSignersPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    _networkJwt: any;
    constructor(svc: JwtSignersPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    confirmAssociatedDelete(jwtSignersWithAssociations: any): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    checkForAssociatedEntities(selectedItems: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    get networkJwt(): string;
    get networkJwtFilename(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<JwtSignersPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JwtSignersPageComponent, "lib-jwt-signers", never, {}, {}, never, never, false, never>;
}

declare class JwtSigner {
    name: string;
    audience: string;
    issuer: string;
    clientId: string;
    claimsProperty: string;
    enabled: boolean;
    useExternalId: boolean;
    externalAuthUrl: string;
    kid: string;
    scopes: string[];
    jwksEndpoint: string;
    certPem: string;
    tags: any;
    targetToken: string;
    enrollToCertEnabled: boolean;
    enrollToTokenEnabled: boolean;
}

declare class JwtSignerFormService {
    private dataService;
    private extService;
    private growlerService;
    private validationService;
    items: any[];
    errors: any[];
    saveDisabled: boolean;
    constructor(dataService: ZitiDataService, extService: ExtensionService, growlerService: GrowlerService, validationService: ValidationService);
    save(formData: any): any;
    getJwtSignerDataModel(formData: any, isUpdate: any): JwtSigner;
    static ɵfac: i0.ɵɵFactoryDeclaration<JwtSignerFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<JwtSignerFormService>;
}

declare const ZAC_LOGIN_SERVICE: InjectionToken<any>;
declare abstract class LoginServiceClass {
    protected httpClient: HttpClient;
    protected settingsService: SettingsServiceClass;
    protected router: Router;
    protected growlerService: GrowlerService;
    checkingControllerOrigin: boolean;
    originIsController: any;
    loginDialogOpen: boolean;
    isCertBasedAuth: boolean;
    certBasedAttempted: boolean;
    serviceUrl: string;
    loginInProgress: boolean;
    callbackRoute: string;
    pendingMfa: boolean;
    mfaAuthQueries: any[];
    completeMfaAuth(code: string): Promise<any>;
    cancelMfaAuth(): void;
    abstract init(): any;
    abstract login(prefix: string, url: string, username: string, password: string, doNav?: any, type?: any, token?: any, isTest?: any): any;
    abstract observeLogin(serviceUrl: string, username: string, password: string, doNav?: any, type?: any, token?: any, isTest?: any): any;
    abstract clearSession(): any;
    abstract checkOriginForController(): Promise<any>;
    abstract logout(): any;
    constructor(httpClient: HttpClient, settingsService: SettingsServiceClass, router: Router, growlerService: GrowlerService);
    getHttpOptions(): any;
    decodeJwt(token: string): any;
}

declare class AuthService {
    private oauthService;
    private http;
    private growlerService;
    private router;
    private settingsService;
    basePath: string;
    constructor(oauthService: OAuthService, http: HttpClient, growlerService: GrowlerService, router: Router, settingsService: SettingsServiceClass);
    resetOAuthService(configKey?: string, tokenTypeKey?: string): void;
    configureOAuth(extJwtSigner: any, callbackUrl?: string, configKey?: any, tokenTypeKey?: any): Promise<any>;
    login(): void;
    logout(): void;
    get accessToken(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
}

declare class JwtSignerFormComponent extends ProjectableForm implements OnInit, OnDestroy {
    svc: JwtSignerFormService;
    private schemaSvc;
    protected settingsService: SettingsService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    private validationService;
    private authService;
    private oauthService;
    private http;
    private loginService;
    errors: any;
    close: EventEmitter<void>;
    formView: string;
    options: any[];
    isEditing: boolean;
    formDataInvalid: boolean;
    editMode: boolean;
    items: any;
    settings: any;
    fileSelectOpening: boolean;
    signatureMethod: string;
    oauthLoading: boolean;
    configKey: string;
    tokenTypeKey: string;
    oidcVerified: boolean;
    oidcErrorMessageSource: any;
    oidcErrorMessageDetail: any;
    oidcErrorMessageDetail2: any;
    oidcErrorMessageDetail3: any;
    jwksValidationError: any;
    oidcAuthTokenClaims: any;
    oidcClaims: any;
    overrideFormData: any;
    usePreviousLocation: boolean;
    entityType: string;
    entityClass: typeof JwtSigner;
    showAutoEnrollHelpModal: boolean;
    filterInput: ElementRef;
    oidcVerification: ElementRef;
    constructor(svc: JwtSignerFormService, schemaSvc: SchemaService, growlerService: GrowlerService, extService: ExtensionService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, route: ActivatedRoute, location: Location, validationService: ValidationService, authService: AuthService, oauthService: OAuthService, http: HttpClient, loginService: LoginServiceClass, dialogForm: MatDialog);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    protected entityUpdated(): void;
    ngOnDestroy(): void;
    headerActionRequested(event: any): void;
    multiActionRequested(action: any): void;
    checkExternalIdToggle(): void;
    clear(): void;
    clearForm(): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get showTokenType(): any;
    get showAutoEnrollment(): boolean;
    get targetToken(): any;
    set targetToken(val: any);
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: any;
    set apiData(data: any);
    dataChanged(event: any): void;
    toggleEnabled(): void;
    toggleUseExternalId(): void;
    toggleEnrollToCertEnabled(): void;
    toggleEnrollToTokenEnabled(): void;
    showAutoEnrollHelp(): void;
    trimWhitespaceScopes(): void;
    radioKeyDownHandler(event: any): void;
    selectSignatureMethod(method: any): void;
    openFileSelect(event: any): void;
    selectPemFile(event: any): void;
    apiActionRequested(action: any): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    scopesOnKeyup(event: any): void;
    get callbackURL(): string;
    copyCallbackURL(): void;
    testOIDCAuthentication(): Promise<void>;
    handleOAuthCallback(): void;
    validateTokenClaims(token: any, formData: any): void;
    testJWKS(): Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<JwtSignerFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JwtSignerFormComponent, "lib-configuration", never, { "errors": { "alias": "errors"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class AuthPoliciesPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    private dialogForm;
    private paging;
    resourceType: string;
    selectedConfig: any;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router, dialogForm: MatDialog);
    initTableColumns(): any;
    checkDefaultAuthPolicy(authPolicy: any): Promise<any>;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    validate: (formData: any) => Promise<CallbackResults>;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthPoliciesPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthPoliciesPageService>;
}

declare class AuthPoliciesPageComponent extends ListPageComponent implements OnInit {
    svc: AuthPoliciesPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    constructor(svc: AuthPoliciesPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthPoliciesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthPoliciesPageComponent, "lib-auth-policies", never, {}, {}, never, never, false, never>;
}

declare class AuthPolicy {
    name: string;
    id: string;
    primary: any;
    secondary: any;
    tags: any;
}

declare class AuthPolicyFormService {
    private dataService;
    private extService;
    private growlerService;
    private validationService;
    items: any[];
    errors: any[];
    saveDisabled: boolean;
    jwtSigners: any[];
    jwtSignerNamedAttributes: any[];
    jwtSignerNamedAttributesMap: {};
    jwtSignersLoading: boolean;
    selectedSecondaryJwtSigner: any;
    filteredJwtSigners: any;
    paging: {
        filter: string;
        noSearch: boolean;
        order: string;
        page: number;
        searchOn: string;
        sort: string;
        total: number;
    };
    constructor(dataService: ZitiDataService, extService: ExtensionService, growlerService: GrowlerService, validationService: ValidationService);
    getJwtSignerNamedAttributes(): Promise<any>;
    getJwtSigners(filters?: any[], page?: number): Promise<void>;
    save(formData: any): any;
    getAuthPolicyDataModel(formData: any, isUpdate: any): AuthPolicy;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthPolicyFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AuthPolicyFormService>;
}

declare class AuthPolicyFormComponent extends ProjectableForm implements OnInit, OnDestroy {
    svc: AuthPolicyFormService;
    private schemaSvc;
    protected settingsService: SettingsService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    private validationService;
    errors: any;
    close: EventEmitter<void>;
    allowedJwtSignerAttributes: any[];
    formView: string;
    options: any[];
    isEditing: boolean;
    formDataInvalid: boolean;
    editMode: boolean;
    items: any;
    settings: any;
    fileSelectOpening: boolean;
    entityType: string;
    entityClass: typeof AuthPolicy;
    jwtSignersFilterChangedDebounced: lodash.DebouncedFunc<(filterText: string) => void>;
    filterInput: ElementRef;
    constructor(svc: AuthPolicyFormService, schemaSvc: SchemaService, growlerService: GrowlerService, extService: ExtensionService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, route: ActivatedRoute, location: Location, validationService: ValidationService);
    ngOnInit(): void;
    protected entityUpdated(): void;
    ngOnDestroy(): void;
    headerActionRequested(event: any): void;
    multiActionRequested(action: any): void;
    clear(): void;
    clearForm(): void;
    allowedJwtSignersChanged(event: any): void;
    getSelectedAttributes(namedAttributes: any, namedAttributeMap: any): any[];
    initSelectedAttributes(): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: any;
    set apiData(data: any);
    dataChanged(event: any): void;
    toggleCertAllowed(): void;
    toggleExtJwtAllowed(): void;
    toggleUpdbAllowed(): void;
    toggleAllowExpiredCerts(): void;
    toggleUpdbMixed(): void;
    toggleUpdbNumeric(): void;
    toggleUpdbSpecial(): void;
    toggleRequireTotp(): void;
    openFileSelect(event: any): void;
    selectPemFile(event: any): void;
    apiActionRequested(action: any): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    scopesOnKeyup(event: any): void;
    jwtSignerFilterChanged(filterText: string): void;
    secondaryJwtSignerChanged(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthPolicyFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthPolicyFormComponent, "lib-configuration", never, { "errors": { "alias": "errors"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class PreviewSelectionsComponent implements OnInit {
    private dialogRef;
    data: any;
    private zitiService;
    private servicePageService;
    private growlerService;
    allItem: {
        name: string;
        id: string;
        associatedConfigs: any[];
        associatedServicePolicies: any[];
    };
    dataObj: any;
    allConfigs: any[];
    allServicePolicies: any[];
    allConfigsCount: number;
    allServicePoliciesCount: number;
    selectedItem: any;
    infoMessage: any;
    state: string;
    isLoading: boolean;
    selectedItems: any[];
    constructor(dialogRef: MatDialogRef<PreviewSelectionsComponent>, data: any, zitiService: ZitiDataService, servicePageService: ServicesPageService, growlerService: GrowlerService);
    ngOnInit(): void;
    initSelectedServicesTemp(): void;
    previewItem(item: any): void;
    confirm(): void;
    return(): void;
    cancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewSelectionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewSelectionsComponent, "preview-selections", never, {}, {}, never, never, false, never>;
}

declare class CertificateAuthoritiesPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    private dialogForm;
    private paging;
    resourceType: string;
    selectedConfig: any;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router, dialogForm: MatDialog);
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    validate: (formData: any) => Promise<CallbackResults>;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    verifyCert(itemId: any, basePath?: any): void;
    getJwt(id: any): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CertificateAuthoritiesPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CertificateAuthoritiesPageService>;
}

declare class CertificateAuthoritiesPageComponent extends ListPageComponent implements OnInit {
    svc: CertificateAuthoritiesPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    constructor(svc: CertificateAuthoritiesPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    gridReady(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CertificateAuthoritiesPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CertificateAuthoritiesPageComponent, "lib-auth-policies", never, {}, {}, never, never, false, never>;
}

declare class CertificateAuthority {
    name: string;
    id: string;
    isAutoCaEnrollmentEnabled: boolean;
    isOttCaEnrollmentEnabled: boolean;
    identityRoles: any[];
    identityNameFormat: string;
    isAuthEnabled: boolean;
    certPem: string;
    externalIdClaim: any;
    tags: any;
    verificationToke: string;
}

declare class CertificateAuthorityFormService {
    private dataService;
    private extService;
    private growlerService;
    private validationService;
    items: any[];
    errors: any[];
    saveDisabled: boolean;
    jwtSigners: any[];
    jwtSignerNamedAttributes: any[];
    jwtSignerNamedAttributesMap: {};
    jwtSignersLoading: boolean;
    selectedSecondaryJwtSigner: any;
    filteredJwtSigners: any;
    paging: {
        filter: string;
        noSearch: boolean;
        order: string;
        page: number;
        searchOn: string;
        sort: string;
        total: number;
    };
    constructor(dataService: ZitiDataService, extService: ExtensionService, growlerService: GrowlerService, validationService: ValidationService);
    save(formData: any): any;
    getIdentityRoleAttributes(): Promise<any>;
    getAuthPolicyDataModel(formData: any, isUpdate: any): CertificateAuthority;
    static ɵfac: i0.ɵɵFactoryDeclaration<CertificateAuthorityFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CertificateAuthorityFormService>;
}

declare class CertificateAuthorityFormComponent extends ProjectableForm implements OnInit, OnDestroy {
    svc: CertificateAuthorityFormService;
    private schemaSvc;
    protected settingsService: SettingsService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    private validationService;
    errors: any;
    close: EventEmitter<void>;
    _externalIdClaim: boolean;
    formView: string;
    options: any[];
    isEditing: boolean;
    formDataInvalid: boolean;
    editMode: boolean;
    items: any;
    settings: any;
    fileSelectOpening: boolean;
    identityRoleAttributes: any[];
    badges: any[];
    entityType: string;
    entityClass: typeof CertificateAuthority;
    locations: string[];
    matchers: string[];
    parsers: string[];
    filterInput: ElementRef;
    constructor(svc: CertificateAuthorityFormService, schemaSvc: SchemaService, growlerService: GrowlerService, extService: ExtensionService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, route: ActivatedRoute, location: Location, validationService: ValidationService);
    ngOnInit(): void;
    protected entityUpdated(): void;
    ngOnDestroy(): void;
    headerActionRequested(event: any): void;
    multiActionRequested(action: any): void;
    externalIdClaimChanged(): void;
    clear(): void;
    clearForm(): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: any;
    set apiData(data: any);
    dataChanged(event: any): void;
    get externalIdClaim(): boolean;
    set externalIdClaim(val: boolean);
    toggleSwitch(prop: any): void;
    openFileSelect(event: any): void;
    selectPemFile(event: any): void;
    apiActionRequested(action: any): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    verifyCertificate(event: any): void;
    get claimLocation(): any;
    set claimLocation(loc: any);
    get matcher(): any;
    set matcher(matcher: any);
    get parser(): any;
    set parser(parser: any);
    get index(): any;
    set index(index: any);
    get matcherCriteria(): any;
    set matcherCriteria(matcherCriteria: any);
    get parserCriteria(): any;
    set parserCriteria(parserCriteria: any);
    static ɵfac: i0.ɵɵFactoryDeclaration<CertificateAuthorityFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CertificateAuthorityFormComponent, "lib-certificate-authority", never, { "errors": { "alias": "errors"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class VerifyCertificateService {
    private dataService;
    private extService;
    private growlerService;
    private validationService;
    items: any[];
    errors: any[];
    saveDisabled: boolean;
    paging: {
        filter: string;
        noSearch: boolean;
        order: string;
        page: number;
        searchOn: string;
        sort: string;
        total: number;
    };
    constructor(dataService: ZitiDataService, extService: ExtensionService, growlerService: GrowlerService, validationService: ValidationService);
    save(formData: any, cert: any): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VerifyCertificateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<VerifyCertificateService>;
}

declare class VerifyCertificateComponent extends ProjectableForm implements OnInit, OnDestroy {
    svc: VerifyCertificateService;
    private schemaSvc;
    protected settingsService: SettingsService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    private validationService;
    errors: any;
    close: EventEmitter<void>;
    _externalIdClaim: boolean;
    formView: string;
    options: any[];
    isEditing: boolean;
    formDataInvalid: boolean;
    editMode: boolean;
    items: any;
    settings: any;
    fileSelectOpening: boolean;
    identityRoleAttributes: any[];
    entityType: string;
    entityClass: typeof CertificateAuthority;
    locations: string[];
    matchers: string[];
    parsers: string[];
    certificate: string;
    certErrorMessage: string;
    filterInput: ElementRef;
    constructor(svc: VerifyCertificateService, schemaSvc: SchemaService, growlerService: GrowlerService, extService: ExtensionService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, route: ActivatedRoute, location: Location, validationService: ValidationService);
    ngOnInit(): void;
    protected entityUpdated(): void;
    ngOnDestroy(): void;
    headerActionRequested(event: any): void;
    clear(): void;
    clearForm(): void;
    copyToClipboard(val: any): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: any;
    set apiData(data: any);
    dataChanged(event: any): void;
    openFileSelect(event: any): void;
    selectPemFile(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VerifyCertificateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VerifyCertificateComponent, "lib-certificate-authority", never, { "errors": { "alias": "errors"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class LoginDialogComponent implements OnInit {
    svc: LoginServiceClass;
    private settingsService;
    data: any;
    private router;
    private dialogRef;
    dataObj: {};
    selectedEdgeController: string;
    username: string;
    password: string;
    loginFailed: boolean;
    edgeControllerList: any[];
    showNoControllers: boolean;
    constructor(svc: LoginServiceClass, settingsService: SettingsServiceClass, data: any, router: Router, dialogRef: MatDialogRef<LoginDialogComponent>);
    ngOnInit(): void;
    settingsReturned(settings: any): void;
    edgeChanged(event?: any): void;
    login(): void;
    close(): void;
    returnToLoginPage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoginDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoginDialogComponent, "lib-confirm", never, {}, {}, never, never, false, never>;
}

declare class PostureChecksPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    private paging;
    resourceType: string;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router);
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PostureChecksPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PostureChecksPageService>;
}

declare class PostureChecksPageComponent extends ListPageComponent implements OnInit {
    svc: PostureChecksPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    constructor(svc: PostureChecksPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PostureChecksPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PostureChecksPageComponent, "lib-configurations", never, {}, {}, never, never, false, never>;
}

declare class PostureCheck {
    name: string;
    id: string;
    typeId: string;
    semantic: string;
    roleAttributes: any[];
    domains: any[];
    macAddresses: any[];
    operatingSystems: any[];
    processes: any[];
    process: any;
    promptOnWake: boolean;
    promptOnUnlock: boolean;
    timeoutSeconds: number;
    tags: any;
}

declare class PostureCheckFormService {
    private dataService;
    private extService;
    private schemaSvc;
    private growlerService;
    private validationService;
    items: any[];
    errors: any[];
    saveDisabled: boolean;
    constructor(dataService: ZitiDataService, extService: ExtensionService, schemaSvc: SchemaService, growlerService: GrowlerService, validationService: ValidationService);
    save(formData: any): any;
    getConfigTypeDataModel(formData: any, isUpdate: any): PostureCheck;
    static ɵfac: i0.ɵɵFactoryDeclaration<PostureCheckFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PostureCheckFormService>;
}

declare class PostureCheckFormComponent extends ProjectableForm implements OnInit, OnDestroy {
    svc: PostureCheckFormService;
    private schemaSvc;
    protected settingsService: SettingsService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    private validationService;
    errors: any;
    close: EventEmitter<void>;
    options: any[];
    isEditing: boolean;
    formView: string;
    formDataInvalid: boolean;
    editMode: boolean;
    items: any;
    associatedServices: any[];
    associatedServiceNames: any[];
    servicesLoading: boolean;
    settings: any;
    pcRoleAttributes: any[];
    postureCheckTypes: any[];
    processMultiItems: {
        hashes: any[];
        osType: string;
        path: string;
        signerFingerprints: any[];
    }[];
    osTypes: {
        name: string;
        type: string;
    }[];
    osCheckData: {
        Android: {
            type: string;
            versions: any[];
            min: string;
            max: string;
            enabled: boolean;
            isAdvanced: boolean;
        };
        iOS: {
            type: string;
            versions: any[];
            min: string;
            max: string;
            enabled: boolean;
            isAdvanced: boolean;
        };
        Linux: {
            type: string;
            versions: any[];
            min: string;
            max: string;
            enabled: boolean;
            isAdvanced: boolean;
        };
        macOS: {
            type: string;
            versions: any[];
            min: string;
            max: string;
            enabled: boolean;
            isAdvanced: boolean;
        };
        Windows: {
            type: string;
            versions: any[];
            min: string;
            max: string;
            enabled: boolean;
            isAdvanced: boolean;
        };
        WindowsServer: {
            type: string;
            versions: any[];
            min: string;
            max: string;
            enabled: boolean;
            isAdvanced: boolean;
        };
    };
    entityType: string;
    entityClass: typeof PostureCheck;
    constructor(svc: PostureCheckFormService, schemaSvc: SchemaService, growlerService: GrowlerService, extService: ExtensionService, settingsService: SettingsService, zitiService: ZitiDataService, router: Router, route: ActivatedRoute, location: Location, validationService: ValidationService, dialogForm: MatDialog);
    ngOnInit(): void;
    entityUpdated(): void;
    getMinMaxVersions(version: any): {
        min: any;
        max: any;
    };
    parseOperatingSystems(): void;
    getOperatingSystemsData(): any[];
    getOSVersionData(os: any): any[];
    ngOnDestroy(): void;
    getIdentityRoleAttributes(): void;
    getPostureCheckTypes(): Promise<void>;
    headerActionRequested(event: any): void;
    multiActionRequested(action: any): void;
    removeProcessItem(index: any): void;
    addProcessItem(): void;
    apiActionRequested(action: any): void;
    copyCLICommand(): void;
    copyCURLCommand(): void;
    clear(): void;
    clearForm(): void;
    save(event?: any): Promise<void>;
    validate(): boolean;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: any;
    set apiData(data: any);
    toggleOS(os: any): void;
    toggleMFAPrompt(type: any): void;
    dataChanged(event: any): void;
    preventEnterProp(event: any): void;
    pcTypeChanged(event: any): void;
    macAddressesChange(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PostureCheckFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PostureCheckFormComponent, "lib-posture-check", never, { "errors": { "alias": "errors"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class SessionsPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    DEFAULT_PAGING: any;
    private paging;
    resourceType: string;
    selectedConfig: any;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router);
    initTableColumns(): any;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SessionsPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SessionsPageService>;
}

declare class SessionsPageComponent extends ListPageComponent implements OnInit {
    svc: SessionsPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    constructor(svc: SessionsPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    openBulkDelete(selectedItems: any, label: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SessionsPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SessionsPageComponent, "lib-sessions", never, {}, {}, never, never, false, never>;
}

declare class Session {
    name: string;
    tags: any;
    serviceId: string;
    token: string;
    type: string;
    servicePolicies: any[];
    identityId: string;
    service: any;
    edgeRouters: any[];
    apiSessionId: string;
    apiSession: any;
    updatedAt: any;
    createdAt: any;
    id: string;
}

declare class SessionFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    private extService;
    associatedIdentities: any;
    associatedIdentityNames: any;
    associatedServices: any;
    associatedServiceNames: any;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService);
    save(formData: any): Promise<any>;
    getSessionDataModel(formData: any, isUpdate: any): Session;
    copyToClipboard(val: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SessionFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SessionFormService>;
}

declare class SessionFormComponent extends ProjectableForm implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    protected settingsService: SettingsService;
    svc: SessionFormService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    edgeRouterRoleAttributes: any[];
    close: EventEmitter<any>;
    headerToggle: boolean;
    entityType: string;
    entityClass: typeof Session;
    moment: typeof moment$1;
    associatedIdentity: any;
    formView: string;
    isEditing: boolean;
    servicesLoading: boolean;
    identityLoading: boolean;
    authPolicies: any;
    associatedEdgeRouters: any[];
    associatedServicePolicies: any[];
    associatedEdgeRoutersMap: {};
    associatedServicePoliciesMap: {};
    settings: any;
    constructor(settingsService: SettingsService, svc: SessionFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location);
    ngOnInit(): void;
    entityUpdated(): void;
    initAssociatedEntities(): void;
    getAssociatedIdentity(): void;
    getAssociatedEdgeRouters(): void;
    getAssociatedServicePolicies(): void;
    previewEdgeRouter(routerName: any, router: any): void;
    previewServicePolicy(policyName: any, router: any): void;
    identityNameLinkClicked(event: any): void;
    serviceNameLinkClicked(event: any): void;
    apiSessionLinkClicked(event: any): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    get hasEnrolmentToken(): boolean;
    headerActionRequested(action: any): void;
    save(event?: any): Promise<void>;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: {};
    set apiData(data: any);
    toggleDisabled(state?: any): void;
    toggleNoTraversal(): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SessionFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SessionFormComponent, "lib-sessions-form", never, { "edgeRouterRoleAttributes": { "alias": "edgeRouterRoleAttributes"; "required": false; }; "headerToggle": { "alias": "headerToggle"; "required": false; }; }, { "close": "close"; }, never, ["[slot=column-1-slot-1]"], false, never>;
}

declare class ApiSessionsPageService extends ListPageServiceClass {
    private schemaSvc;
    protected router: Router;
    DEFAULT_PAGING: any;
    private paging;
    resourceType: string;
    selectedConfig: any;
    modalType: string;
    menuItems: {
        name: string;
        action: string;
    }[];
    constructor(schemaSvc: SchemaService, settings: SettingsService, filterService: DataTableFilterService, csvDownloadService: CsvDownloadService, extService: ExtensionService, router: Router);
    initTableColumns(): any;
    openIdentityForm(itemId?: string, basePath?: any): void;
    getData(filters?: FilterObj[], sort?: any): Promise<any>;
    private processData;
    private addActionsPerRow;
    openUpdate(item?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ApiSessionsPageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ApiSessionsPageService>;
}

declare class APISessionsPageComponent extends ListPageComponent implements OnInit {
    svc: ApiSessionsPageService;
    private tabNames;
    private extService;
    title: string;
    tabs: {
        url: string;
        label: string;
    }[];
    isLoading: boolean;
    formDataChanged: boolean;
    constructor(svc: ApiSessionsPageService, filterService: DataTableFilterService, tabNames: TabNameService, consoleEvents: ConsoleEventsService, dialogForm: MatDialog, extService: ExtensionService);
    ngOnInit(): void;
    headerActionClicked(action: string): void;
    tableAction(event: any): void;
    trackMenuAction(action: string, item: any): void;
    openBulkDelete(selectedItems: any, label: any): void;
    deleteItem(item: any): void;
    closeModal(event: any): void;
    dataChanged(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<APISessionsPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<APISessionsPageComponent, "lib-api-sessions", never, {}, {}, never, never, false, never>;
}

declare class APISessionFormService {
    settingsService: SettingsService;
    private zitiService;
    private growlerService;
    private extService;
    associatedIdentities: any;
    associatedIdentityNames: any;
    associatedServices: any;
    associatedServiceNames: any;
    constructor(settingsService: SettingsService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService);
    save(formData: any): Promise<any>;
    getEdgeRouterDataModel(formData: any, isUpdate: any): EdgeRouter;
    getAuthPolicies(): Promise<any[]>;
    copyToClipboard(val: any): void;
    getAssociatedServices(id: any): void;
    getAssociatedIdentities(id: any): void;
    refreshRouter(id: any): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<APISessionFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<APISessionFormService>;
}

declare class APISession {
    name: string;
    tags: any;
    serviceId: string;
    token: string;
    type: string;
    servicePolicies: any[];
    identityId: string;
    service: any;
    edgeRouters: any[];
    isCertExtendable: boolean;
    isMfaComplete: boolean;
    isMfaRequired: boolean;
    updatedAt: any;
    createdAt: any;
    id: string;
}

declare class APISessionFormComponent extends ProjectableForm implements OnInit, OnChanges, OnDestroy, AfterViewInit {
    protected settingsService: SettingsService;
    svc: APISessionFormService;
    zitiService: ZitiDataService;
    protected router: Router;
    protected route: ActivatedRoute;
    edgeRouterRoleAttributes: any[];
    close: EventEmitter<any>;
    headerToggle: boolean;
    entityType: string;
    entityClass: typeof APISession;
    moment: typeof moment$1;
    associatedIdentity: any;
    formView: string;
    isEditing: boolean;
    servicesLoading: boolean;
    identityLoading: boolean;
    authPolicies: any;
    associatedEdgeRouters: any[];
    associatedServicePolicies: any[];
    settings: any;
    constructor(settingsService: SettingsService, svc: APISessionFormService, zitiService: ZitiDataService, growlerService: GrowlerService, extService: ExtensionService, router: Router, route: ActivatedRoute, location: Location);
    ngOnInit(): void;
    identityNameLinkClicked(event: any): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    get hasEnrolmentToken(): boolean;
    headerActionRequested(action: any): void;
    save(event?: any): Promise<void>;
    get apiCallURL(): string;
    get apiData(): any;
    _apiData: {};
    set apiData(data: any);
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<APISessionFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<APISessionFormComponent, "lib-sessions-form", never, { "edgeRouterRoleAttributes": { "alias": "edgeRouterRoleAttributes"; "required": false; }; "headerToggle": { "alias": "headerToggle"; "required": false; }; }, { "close": "close"; }, never, ["[slot=column-1-slot-1]"], false, never>;
}

declare class CallbackComponent implements OnInit {
    private oauthService;
    private loginService;
    private growlerService;
    private router;
    private route;
    private zitiService;
    private settingsService;
    constructor(oauthService: OAuthService, loginService: LoginServiceClass, growlerService: GrowlerService, router: Router, route: ActivatedRoute, zitiService: ZitiDataService, settingsService: SettingsServiceClass);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CallbackComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CallbackComponent, "lib-callback", never, {}, {}, never, never, false, never>;
}

declare class ProgressMeterStep {
    index: number;
    label: string;
    state: '' | 'TO_DO' | 'IN_PROGRESS' | 'COMPLETE' | 'ERROR' | 'WARNING';
}
declare class ProgressMeterComponent {
    errors: any;
    title: string;
    steps: ProgressMeterStep[];
    currentStepIndex: number;
    currentStepChange: EventEmitter<any>;
    constructor();
    getProgressBarStyle(index: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressMeterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressMeterComponent, "lib-progress-meter", never, { "title": { "alias": "title"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "currentStepIndex": { "alias": "currentStepIndex"; "required": false; }; }, { "currentStepChange": "currentStepChange"; }, never, never, false, never>;
}

declare class ProgressWizardStep {
    index: number;
    label: string;
}
declare class ProgressWizardComponent {
    errors: any;
    title: string;
    steps: ProgressWizardStep[];
    backButtonLabel: string;
    nextButtonLabel: string;
    nextButtonDisabled: boolean;
    titleImageSrc: string;
    showCloseButton: boolean;
    currentStepIndex: number;
    currentStepIndexChange: EventEmitter<any>;
    close: EventEmitter<any>;
    done: EventEmitter<any>;
    stepChanged: EventEmitter<any>;
    constructor();
    cancel(): void;
    confirm(): void;
    nextStep(): void;
    goToStep(stepNum: any): void;
    prevStep(): void;
    get progressTrackHeight(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressWizardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressWizardComponent, "lib-progress-wizard", never, { "title": { "alias": "title"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "backButtonLabel": { "alias": "backButtonLabel"; "required": false; }; "nextButtonLabel": { "alias": "nextButtonLabel"; "required": false; }; "nextButtonDisabled": { "alias": "nextButtonDisabled"; "required": false; }; "titleImageSrc": { "alias": "titleImageSrc"; "required": false; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; }; "currentStepIndex": { "alias": "currentStepIndex"; "required": false; }; }, { "currentStepIndexChange": "currentStepIndexChange"; "close": "close"; "done": "done"; "stepChanged": "stepChanged"; }, never, ["*"], false, never>;
}

declare class SettingsComponent implements OnInit {
    pageTitle: string;
    isDark: boolean;
    hideTags: boolean;
    transitions: boolean;
    isFilterAfterSave: boolean;
    primaryColor: any;
    secondaryColor: any;
    constructor();
    ngOnInit(): void;
    swap(): void;
    hide(): void;
    filterAfter(): void;
    transitionsChange(): void;
    updateTransitions(): void;
    onPrimaryColorChange(color: any): void;
    onSecondaryColorChange(color: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SettingsComponent, "lib-settings", never, {}, {}, never, never, false, never>;
}

declare class ProfileComponent implements OnDestroy {
    private zitiService;
    private settingsService;
    private growlerService;
    pageTitle: string;
    currentPassword: string;
    newPassword: string;
    confirmPassword: string;
    passwordChangeDisabled: boolean;
    passwordChangeMessage: string;
    private settingsSubscription?;
    constructor(zitiService: ZitiDataService, settingsService: SettingsServiceClass, growlerService: GrowlerService);
    ngOnDestroy(): void;
    private updatePasswordChangeState;
    resetPassword(): void;
    validate(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProfileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProfileComponent, "lib-profile", never, {}, {}, never, never, false, never>;
}

declare class GeolocationService {
    private zitiDataService;
    private growlerService;
    private originalLocations;
    constructor(zitiDataService: ZitiDataService, growlerService: GrowlerService);
    /**
     * Update geolocation tag locally (in-memory only, not saved to backend)
     */
    updateGeolocationLocal(item: any, lat: number, lng: number): void;
    /**
     * Save geolocation changes to backend
     */
    saveGeolocation(item: any, type: string, routerTypes?: Map<string, string>): Promise<void>;
    /**
     * Remove geolocation tag from entity
     */
    removeGeolocation(item: any, type: string, routerTypes?: Map<string, string>): Promise<void>;
    /**
     * Check if an entity has unsaved location changes
     */
    hasUnsavedChanges(item: any): boolean;
    /**
     * Track original location for an entity
     */
    trackOriginalLocation(item: any): void;
    /**
     * Parse geolocation tag into lat/lng coordinates
     */
    parseGeolocation(geolocationTag: string): {
        lat: number;
        lng: number;
    } | null;
    /**
     * Clear all tracked original locations
     */
    clearTrackedLocations(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeolocationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GeolocationService>;
}

interface CircuitPathNode {
    id: string;
    name: string;
    type: 'identity' | 'routers';
    lat: number;
    lng: number;
}
interface CircuitPath {
    nodes: CircuitPathNode[];
    coordinates: [number, number][];
}
declare class CircuitCalculationService {
    constructor();
    /**
     * Find the host identity ID for a circuit using various fallback strategies
     */
    findHostIdentityId(circuit: any, terminators: any[]): string | null;
    /**
     * Build a circuit path data structure (client identity → routers → hosting identity)
     * Returns null if the path cannot be built (missing locations, etc.)
     */
    buildCircuitPath(circuit: any, identities: any[], identityLocations: Map<string, {
        lat: number;
        lng: number;
        name: string;
    }>, routerLocations: Map<string, {
        lat: number;
        lng: number;
        name: string;
    }>, terminators: any[]): CircuitPath | null;
    /**
     * Check if all routers in a circuit path are in the visible set
     */
    areAllRoutersVisible(circuit: any, visibleRouterIds: Set<string>): boolean;
    /**
     * Check if at least one router in a circuit path is in the visible set
     */
    hasAnyVisibleRouter(circuit: any, visibleRouterIds: Set<string>): boolean;
    /**
     * Filter a circuit path to only include visible entities
     * (all identities + only visible routers)
     */
    filterCircuitPathToVisible(circuitPath: CircuitPath, visibleRouterIds: Set<string>): CircuitPath;
    /**
     * Check if a circuit's service is in the visible set
     */
    isCircuitServiceVisible(circuit: any, visibleServiceIds: Set<string>, hasServiceFilters: boolean): boolean;
    /**
     * Calculate the count of unique services that have active circuits
     */
    calculateServicesWithActiveCircuits(circuits: any[]): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<CircuitCalculationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CircuitCalculationService>;
}

interface CircuitHop {
    from: string;
    fromType: string;
    fromId: string;
    fromHasLocation: boolean;
    to: string;
    toType: string;
    toId: string;
    toHasLocation: boolean;
    isVisible: boolean;
    latencyMs?: number;
}
interface CircuitPathData {
    pathNodes: any[];
    pathCoordinates: [number, number][];
    routerNames: string[];
    entityIds: string[];
    entityTypes: string[];
    circuitHops: CircuitHop[];
    circuitRouters: any[];
    clientId: string | null;
    clientName: string;
    hostId: string | null;
    hostName: string;
    hasCompleteGeolocation: boolean;
    missingLocations: string[];
    visibleSegmentToHopIndex: Map<number, number>;
}
declare class CircuitPathBuilderService {
    /**
     * Builds complete circuit path data structure with coordinates, hops, and router details
     * @param circuit - The circuit object
     * @param routerLocations - Map of router IDs to location data
     * @param identityLocations - Map of identity IDs to location data
     * @param routers - Array of all router objects
     * @param identities - Array of all identity objects
     * @param links - Array of all link objects (for latency data on router-to-router hops)
     * @returns Complete circuit path data or null if path cannot be built
     */
    buildCircuitPathData(circuit: any, routerLocations: Map<string, any>, identityLocations: Map<string, any>, routers: any[], identities: any[], links?: any[]): CircuitPathData | null;
    /**
     * Builds a simplified circuit path for rendering (coordinates only)
     * @param circuit - The circuit object
     * @param routerLocations - Map of router IDs to location data
     * @param identityLocations - Map of identity IDs to location data
     * @returns Array of coordinates or null if path cannot be built
     */
    buildSimpleCircuitPath(circuit: any, routerLocations: Map<string, any>, identityLocations: Map<string, any>): [number, number][] | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<CircuitPathBuilderService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CircuitPathBuilderService>;
}

declare class CircuitFilterService {
    /**
     * Gets filtered identity IDs based on selected service and identity filters
     * @param identities - All identities
     * @param circuits - All circuits
     * @param terminators - All terminators
     * @param selectedServiceFilters - Selected service filters
     * @param selectedIdentityFilters - Selected identity filters
     * @returns Set of identity IDs that match the filters
     */
    getFilteredIdentityIds(identities: any[], circuits: any[], terminators: any[], selectedServiceFilters: any[], selectedIdentityFilters: any[]): Set<string>;
    /**
     * Gets filtered router IDs based on selected service and identity filters
     * @param identities - All identities
     * @param circuits - All circuits
     * @param terminators - All terminators
     * @param routerLocations - Map of router locations
     * @param selectedServiceFilters - Selected service filters
     * @param selectedIdentityFilters - Selected identity filters
     * @returns Set of router IDs that match the filters
     */
    getFilteredRouterIds(identities: any[], circuits: any[], terminators: any[], routerLocations: Map<string, any>, selectedServiceFilters: any[], selectedIdentityFilters: any[]): Set<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CircuitFilterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CircuitFilterService>;
}

/**
 * Service responsible for managing map markers (identities and routers)
 * Handles marker creation, updates, selection, and user interactions
 */
declare class MapMarkerService {
    private geolocationService;
    private growlerService;
    private dialogForm;
    identityMarkers: any[];
    routerMarkers: any[];
    markerToIdentityId: Map<any, string>;
    markerToRouterId: Map<any, string>;
    currentDraggableMarker: any;
    selectedMarker: any;
    circuitMarkerIds: Set<string>;
    markerClicked: EventEmitter<{
        item: any;
        type: string;
        location: {
            lat: number;
            lng: number;
        };
    }>;
    geolocationRemoved: EventEmitter<{
        item: any;
        type: string;
        marker: any;
    }>;
    geolocationUpdated: EventEmitter<{
        item: any;
        lat: number;
        lng: number;
        type: string;
    }>;
    private contextMenuCleanup;
    private dialogRef;
    constructor(geolocationService: GeolocationService, growlerService: GrowlerService, dialogForm: MatDialog);
    /**
     * Creates a Leaflet marker icon with dynamic styling
     * @param type - 'identity' or 'routers'
     * @param isSelected - Whether the marker is selected
     * @param scale - Scale factor for the icon (default 0.85)
     * @returns Leaflet icon object
     */
    createMarkerIcon(type: string, isSelected: boolean, scale?: number): any;
    /**
     * Adds markers to the map for a collection of entities
     * @param data - Array of entities (identities or routers)
     * @param type - 'identity' or 'routers'
     * @param clusterGroup - Leaflet cluster group to add markers to
     * @param map - Leaflet map instance (fallback if no cluster group)
     * @param routerLocations - Map to store router locations
     * @param identityLocations - Map to store identity locations
     * @returns Array of created markers
     */
    addMarkers(data: any[], type: string, clusterGroup: any, map: any, routerLocations: Map<string, any>, identityLocations: Map<string, any>): any[];
    /**
     * Finds a marker by item ID and type
     * @param itemId - Entity ID
     * @param itemType - 'identity' or 'routers'
     * @param identityClusterGroup - Identity cluster group
     * @param routerClusterGroup - Router cluster group
     * @returns Marker object or null
     */
    findMarkerByItemId(itemId: string, itemType: string, identityClusterGroup: any, routerClusterGroup: any): any;
    /**
     * Updates marker icon based on selection state and circuit membership
     * @param marker - Marker to update
     * @param isSelected - Whether the marker is selected
     */
    updateMarkerIcon(marker: any, isSelected: boolean): void;
    /**
     * Applies opacity to all markers except the selected one
     * @param selectedMarker - The marker to keep at full opacity
     * @param opacity - Opacity value for non-selected markers (default 0.7)
     * @param identityClusterGroup - Identity cluster group
     * @param routerClusterGroup - Router cluster group
     */
    applyMarkerOpacity(selectedMarker: any, opacity: number, identityClusterGroup: any, routerClusterGroup: any): void;
    /**
     * Resets opacity for all markers to full visibility
     * @param identityClusterGroup - Identity cluster group
     * @param routerClusterGroup - Router cluster group
     */
    resetMarkerOpacity(identityClusterGroup: any, routerClusterGroup: any): void;
    /**
     * Scales markers that are part of active circuits
     * @param scaleUp - Whether to scale up (true) or down (false)
     * @param identityClusterGroup - Identity cluster group
     * @param routerClusterGroup - Router cluster group
     */
    scaleCircuitMarkers(scaleUp: boolean, identityClusterGroup: any, routerClusterGroup: any): void;
    /**
     * Clears selected marker state and resets opacity
     * @param identityClusterGroup - Identity cluster group
     * @param routerClusterGroup - Router cluster group
     */
    clearSelectedMarker(identityClusterGroup: any, routerClusterGroup: any): void;
    /**
     * Sets a marker as selected and applies visual effects
     * @param marker - Marker to select
     * @param identityClusterGroup - Identity cluster group
     * @param routerClusterGroup - Router cluster group
     */
    setSelectedMarker(marker: any, identityClusterGroup: any, routerClusterGroup: any): void;
    /**
     * Removes a marker from the map and collections
     * @param marker - Marker to remove
     * @param type - 'identity' or 'routers'
     * @param identityClusterGroup - Identity cluster group
     * @param routerClusterGroup - Router cluster group
     * @param routerLocations - Router locations map
     * @param identityLocations - Identity locations map
     * @param itemId - Entity ID
     */
    removeMarker(marker: any, type: string, identityClusterGroup: any, routerClusterGroup: any, routerLocations: Map<string, any>, identityLocations: Map<string, any>, itemId: string): void;
    /**
     * Shows context menu for a marker with drag/drop and remove options
     * @param event - Leaflet event object
     * @param marker - Marker to show menu for
     * @param item - Entity data
     * @param type - 'identity' or 'routers'
     * @param routerLocations - Router locations map
     * @param identityLocations - Identity locations map
     */
    private showMarkerContextMenu;
    /**
     * Disables dragging on the current draggable marker
     */
    disableCurrentDraggableMarker(): void;
    /**
     * Clears all markers and resets state
     */
    clearAllMarkers(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapMarkerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MapMarkerService>;
}

/**
 * Service responsible for rendering visual elements on the map
 * Handles circuit lines, router links, and their styling
 */
declare class MapRenderingService {
    private circuitCalculationService;
    private circuitPathBuilderService;
    circuitLines: any[];
    activeCircuitLines: any[];
    linkClicked: EventEmitter<any>;
    circuitSegmentClicked: EventEmitter<any>;
    constructor(circuitCalculationService: CircuitCalculationService, circuitPathBuilderService: CircuitPathBuilderService);
    /**
     * Draws router links on the map
     * @param map - Leaflet map instance
     * @param links - Array of router links
     * @param routerLocations - Map of router locations
     * @param edgeRouters - Array of edge routers (for visibility filtering)
     * @param linksVisible - Whether links should be visible
     */
    drawLinks(map: any, links: any[], routerLocations: Map<string, any>, edgeRouters: any[], linksVisible: boolean): void;
    /**
     * Draws router links filtered by specific router IDs
     * @param map - Leaflet map instance
     * @param links - Array of all router links
     * @param filteredRouterIds - Set of router IDs to filter by
     * @param routerLocations - Map of router locations
     * @param linksVisible - Whether links should be visible
     */
    drawFilteredLinks(map: any, links: any[], filteredRouterIds: Set<string>, routerLocations: Map<string, any>, linksVisible: boolean): void;
    /**
     * Draws active circuits on the map with complex styling and interactions
     * @param map - Leaflet map instance
     * @param circuits - Array of circuits to draw
     * @param identities - Array of identities
     * @param identityLocations - Map of identity locations
     * @param routerLocations - Map of router locations
     * @param terminators - Array of terminators
     * @param edgeRouters - Array of edge routers
     * @param services - Array of services
     * @param selectedServiceAttributes - Array of selected service attribute filters
     * @param selectedServiceNamedAttributes - Array of selected service named attribute filters
     * @param selectedCircuitSegment - Currently selected circuit segment
     * @param activeCircuitsVisible - Whether active circuits should be visible
     * @param isCircuitSelectionActive - Whether a specific circuit is selected
     * @param scaleCircuitMarkersCallback - Callback to scale circuit markers
     * @returns Set of circuit marker IDs
     */
    drawActiveCircuits(map: any, circuits: any[], identities: any[], identityLocations: Map<string, any>, routerLocations: Map<string, any>, terminators: any[], edgeRouters: any[], services: any[], selectedServiceAttributes: any[], selectedServiceNamedAttributes: any[], selectedCircuitSegment: any, activeCircuitsVisible: boolean, isCircuitSelectionActive: boolean, scaleCircuitMarkersCallback: (scaleUp: boolean) => void): Set<string>;
    /**
     * Updates visibility of router links
     * @param map - Leaflet map instance
     * @param linksVisible - Whether links should be visible
     */
    updateLinksVisibility(map: any, linksVisible: boolean): void;
    /**
     * Updates visibility of active circuits
     * @param map - Leaflet map instance
     * @param activeCircuitsVisible - Whether active circuits should be visible
     */
    updateActiveCircuitsVisibility(map: any, activeCircuitsVisible: boolean): void;
    /**
     * Clears all circuit and link lines from the map
     * @param map - Leaflet map instance
     */
    clearAllLines(map: any): void;
    /**
     * Clears only active circuit lines from the map
     * @param map - Leaflet map instance
     */
    clearActiveCircuitLines(map: any): void;
    /**
     * Clears only router link lines from the map
     * @param map - Leaflet map instance
     */
    clearCircuitLines(map: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapRenderingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MapRenderingService>;
}

/**
 * Centralized state management service for the geolocate map component
 * Manages visibility toggles, filter state, side panel state, and entity locations
 */
declare class MapStateService {
    private _clusteringEnabled$;
    private _linksVisible$;
    private _activeCircuitsVisible$;
    private _routersVisible$;
    private _identitiesVisible$;
    private _routerLocations;
    private _identityLocations;
    private _routerTypes;
    private _sidePanelOpen$;
    private _sidePanelType$;
    private _sidePanelData$;
    private _sidePanelCircuits$;
    private _sidePanelWidth$;
    private _selectedCircuit$;
    private _selectedCircuitRouters$;
    private _selectedCircuitSegment$;
    private _selectedUnlocatedCircuit$;
    private _selectedUnlocatedCircuitRouters$;
    private _selectedServiceAttributes$;
    private _selectedServiceNamedAttributes$;
    private _selectedIdentityAttributes$;
    private _selectedIdentityNamedAttributes$;
    private _selectedRouterAttributes$;
    private _selectedConnectionStatus$;
    private _filtersApplied$;
    private _showServiceDropdown$;
    private _showIdentityDropdown$;
    private _showConnectionStatusFilterSelector$;
    clusteringEnabled$: Observable<boolean>;
    linksVisible$: Observable<boolean>;
    activeCircuitsVisible$: Observable<boolean>;
    routersVisible$: Observable<boolean>;
    identitiesVisible$: Observable<boolean>;
    sidePanelOpen$: Observable<boolean>;
    sidePanelType$: Observable<"link" | "marker" | "circuit" | "unlocated" | "entityList" | "servicesWithCircuits">;
    sidePanelData$: Observable<any>;
    sidePanelCircuits$: Observable<any[]>;
    sidePanelWidth$: Observable<number>;
    selectedCircuit$: Observable<any>;
    selectedCircuitRouters$: Observable<any[]>;
    selectedCircuitSegment$: Observable<any>;
    selectedUnlocatedCircuit$: Observable<any>;
    selectedUnlocatedCircuitRouters$: Observable<any[]>;
    selectedServiceAttributes$: Observable<any[]>;
    selectedServiceNamedAttributes$: Observable<any[]>;
    selectedIdentityAttributes$: Observable<any[]>;
    selectedIdentityNamedAttributes$: Observable<any[]>;
    selectedRouterAttributes$: Observable<any[]>;
    selectedConnectionStatus$: Observable<string>;
    filtersApplied$: Observable<boolean>;
    showServiceDropdown$: Observable<boolean>;
    showIdentityDropdown$: Observable<boolean>;
    showConnectionStatusFilterSelector$: Observable<boolean>;
    constructor();
    get clusteringEnabled(): boolean;
    set clusteringEnabled(value: boolean);
    toggleClustering(): void;
    get linksVisible(): boolean;
    set linksVisible(value: boolean);
    toggleLinks(): void;
    get activeCircuitsVisible(): boolean;
    set activeCircuitsVisible(value: boolean);
    toggleActiveCircuits(): void;
    get routersVisible(): boolean;
    set routersVisible(value: boolean);
    toggleRouters(): void;
    get identitiesVisible(): boolean;
    set identitiesVisible(value: boolean);
    toggleIdentities(): void;
    get routerLocations(): Map<string, {
        lat: number;
        lng: number;
        name: string;
    }>;
    setRouterLocation(id: string, location: {
        lat: number;
        lng: number;
        name: string;
    }): void;
    removeRouterLocation(id: string): void;
    clearRouterLocations(): void;
    get identityLocations(): Map<string, {
        lat: number;
        lng: number;
        name: string;
    }>;
    setIdentityLocation(id: string, location: {
        lat: number;
        lng: number;
        name: string;
    }): void;
    removeIdentityLocation(id: string): void;
    clearIdentityLocations(): void;
    get routerTypes(): Map<string, string>;
    setRouterTypes(routerTypes: Map<string, string>): void;
    getRouterType(id: string): string | undefined;
    get sidePanelOpen(): boolean;
    set sidePanelOpen(value: boolean);
    get sidePanelType(): 'marker' | 'link' | 'circuit' | 'unlocated' | 'entityList' | 'servicesWithCircuits' | null;
    set sidePanelType(value: 'marker' | 'link' | 'circuit' | 'unlocated' | 'entityList' | 'servicesWithCircuits' | null);
    get sidePanelData(): any;
    set sidePanelData(value: any);
    get sidePanelCircuits(): any[];
    set sidePanelCircuits(value: any[]);
    get sidePanelWidth(): number;
    set sidePanelWidth(value: number);
    openSidePanel(type: 'marker' | 'link' | 'circuit' | 'unlocated' | 'entityList' | 'servicesWithCircuits', data: any): void;
    closeSidePanel(): void;
    get selectedCircuit(): any;
    set selectedCircuit(value: any);
    get selectedCircuitRouters(): any[];
    set selectedCircuitRouters(value: any[]);
    get selectedCircuitSegment(): any;
    set selectedCircuitSegment(value: any);
    get selectedUnlocatedCircuit(): any;
    set selectedUnlocatedCircuit(value: any);
    get selectedUnlocatedCircuitRouters(): any[];
    set selectedUnlocatedCircuitRouters(value: any[]);
    clearSelectedCircuit(): void;
    clearSelectedUnlocatedCircuit(): void;
    isCircuitSelectionActive(): boolean;
    get selectedServiceAttributes(): any[];
    set selectedServiceAttributes(value: any[]);
    get selectedServiceNamedAttributes(): any[];
    set selectedServiceNamedAttributes(value: any[]);
    get selectedIdentityAttributes(): any[];
    set selectedIdentityAttributes(value: any[]);
    get selectedIdentityNamedAttributes(): any[];
    set selectedIdentityNamedAttributes(value: any[]);
    get selectedRouterAttributes(): any[];
    set selectedRouterAttributes(value: any[]);
    get selectedConnectionStatus(): string;
    set selectedConnectionStatus(value: string);
    get filtersApplied(): boolean;
    set filtersApplied(value: boolean);
    clearAllFilters(): void;
    hasActiveFilters(): boolean;
    get showServiceDropdown(): boolean;
    set showServiceDropdown(value: boolean);
    get showIdentityDropdown(): boolean;
    set showIdentityDropdown(value: boolean);
    get showConnectionStatusFilterSelector(): boolean;
    set showConnectionStatusFilterSelector(value: boolean);
    closeAllDropdowns(): void;
    /**
     * Resets all state to initial values
     */
    resetState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MapStateService>;
}

declare class GeolocateComponent implements OnInit, OnDestroy {
    private zitiDataService;
    private settingsService;
    private router;
    private route;
    private growlerService;
    private dialogForm;
    private geolocationService;
    private mapDataService;
    private circuitCalculationService;
    private circuitPathBuilderService;
    private circuitFilterService;
    mapMarkerService: MapMarkerService;
    mapRenderingService: MapRenderingService;
    mapStateService: MapStateService;
    map: any;
    identityClusterGroup: any;
    routerClusterGroup: any;
    pageTitle: string;
    totalIdentities: number;
    totalServices: number;
    totalConfigs: number;
    totalEdgeRouters: number;
    totalServicePolicies: number;
    totalSessions: number;
    showVisualizer: boolean;
    DEBUG_TEST_LINK_LATENCY: boolean;
    unlocatedIdentities: number;
    unlocatedRouters: number;
    servicesWithActiveCircuits: number;
    geolocatedIdentities: number;
    geolocatedRouters: number;
    servicesWithCircuitsSearch: string;
    unlocatedIdentitiesSearch: string;
    filteredUnlocatedIdentities: any[];
    unlocatedRoutersSearch: string;
    filteredUnlocatedRouters: any[];
    entityListSearch: string;
    entityListPage: number;
    entityListPageSize: number;
    entityListTotal: number;
    filteredEntityList: any[];
    fullEntityList: any[];
    entityListType: string;
    entityListSortColumn: string;
    entityListSortDirection: 'asc' | 'desc';
    entityListLocationFilter: 'all' | 'located' | 'unlocated';
    private draggedEntity;
    private draggedEntityType;
    circuits: any[];
    terminators: any[];
    identities: any[];
    edgeRouters: any[];
    services: any[];
    links: any[];
    entityListPreview: any;
    entityListPreviewType: 'identity' | 'routers' | 'services' | null;
    selectedRouterInPath: string | null;
    circuitPreviewEntity: any;
    circuitPreviewEntityType: string;
    unlocatedPreviewEntity: any;
    unlocatedPreviewType: string;
    unlocatedPreviewHasUnsavedLocation: boolean;
    unlocatedPreviewCircuits: any[];
    isResizing: boolean;
    minPanelWidth: number;
    maxPanelWidth: number;
    startX: number;
    startWidth: number;
    selectedServiceFilters: any[];
    selectedIdentityFilters: any[];
    serviceRoleAttributes: any[];
    serviceNamedAttributes: any[];
    servicesNameIdMap: {
        [key: string]: string;
    };
    servicesIdNameMap: {
        [key: string]: string;
    };
    identityRoleAttributes: any[];
    identityNamedAttributes: any[];
    identitiesNameIdMap: {
        [key: string]: string;
    };
    identitiesIdNameMap: {
        [key: string]: string;
    };
    routerRoleAttributes: any[];
    private subscription;
    private documentClickHandler;
    edgeRoutersInit: boolean;
    identitiesInit: boolean;
    isLoading: boolean;
    Math: Math;
    dialogRef: any;
    constructor(zitiDataService: ZitiDataService, settingsService: SettingsService, router: Router, route: ActivatedRoute, growlerService: GrowlerService, dialogForm: MatDialog, geolocationService: GeolocationService, mapDataService: MapDataService, circuitCalculationService: CircuitCalculationService, circuitPathBuilderService: CircuitPathBuilderService, circuitFilterService: CircuitFilterService, mapMarkerService: MapMarkerService, mapRenderingService: MapRenderingService, mapStateService: MapStateService);
    get selectedRouterAttributes(): any[];
    set selectedRouterAttributes(value: any[]);
    get selectedIdentityAttributes(): any[];
    set selectedIdentityAttributes(value: any[]);
    get selectedIdentityNamedAttributes(): any[];
    set selectedIdentityNamedAttributes(value: any[]);
    get selectedServiceAttributes(): any[];
    set selectedServiceAttributes(value: any[]);
    get selectedServiceNamedAttributes(): any[];
    set selectedServiceNamedAttributes(value: any[]);
    get selectedConnectionStatus(): string;
    set selectedConnectionStatus(value: string);
    get filtersApplied(): boolean;
    set filtersApplied(value: boolean);
    get showConnectionStatusFilterSelector(): boolean;
    set showConnectionStatusFilterSelector(value: boolean);
    get sidePanelOpen(): boolean;
    set sidePanelOpen(value: boolean);
    get sidePanelType(): any;
    set sidePanelType(value: any);
    get sidePanelData(): any;
    set sidePanelData(value: any);
    get sidePanelCircuits(): any[];
    set sidePanelCircuits(value: any[]);
    get routersVisible(): boolean;
    set routersVisible(value: boolean);
    get identitiesVisible(): boolean;
    set identitiesVisible(value: boolean);
    get linksVisible(): boolean;
    set linksVisible(value: boolean);
    get activeCircuitsVisible(): boolean;
    set activeCircuitsVisible(value: boolean);
    get clusteringEnabled(): boolean;
    set clusteringEnabled(value: boolean);
    get selectedCircuit(): any;
    set selectedCircuit(value: any);
    get selectedCircuitRouters(): any[];
    set selectedCircuitRouters(value: any[]);
    get selectedCircuitSegment(): any;
    set selectedCircuitSegment(value: any);
    get selectedUnlocatedCircuit(): any;
    set selectedUnlocatedCircuit(value: any);
    get selectedUnlocatedCircuitRouters(): any[];
    set selectedUnlocatedCircuitRouters(value: any[]);
    routerFilterSelector: any;
    identityFilterSelector: any;
    serviceFilterSelector: any;
    connectionStatusFilterSelector: ElementRef;
    ngOnInit(): void;
    getRoleAttributest(): Promise<[void, void, void]>;
    getRouterRoleAttributes(): Promise<any>;
    getIdentityRoleAttributes(): Promise<any>;
    getServiceRoleAttributes(): Promise<any>;
    loadEntityCounts(): Promise<void>;
    loadMapData(): Promise<void>;
    loadRouters(): Promise<{
        data: any[];
    }>;
    loadIdentities(): Promise<void>;
    loadServices(): Promise<void>;
    addMarkers(data: any[], type: string, skipAutoFit?: boolean): void;
    loadLinks(): void;
    loadCircuits(): void;
    loadTerminators(): void;
    drawLinks(links: any[]): void;
    toggleClustering(): void;
    checkLinks(): void;
    toggleLinks(): void;
    checkVisualizerFeature(): void;
    disableMapScroll(): void;
    enableMapScroll(): void;
    getFilteredIdentityIds(): Set<string>;
    getFilteredRouterIds(): Set<string>;
    applyFilters(): void;
    showAllMarkers(): void;
    drawFilteredLinks(filteredRouterIds: Set<string>): void;
    drawActiveCircuits(circuits: any[], isSelectedCircuit?: boolean): void;
    scaleCircuitMarkers(scaleUp: boolean): void;
    applyMarkerOpacity(selectedMarker: any, opacity?: number): void;
    resetMarkerOpacity(): void;
    toggleActiveCircuits(): void;
    toggleRouters(): void;
    toggleIdentities(): void;
    checkRouters(): void;
    checkIdentities(): void;
    getMarkerIdentityId(marker: any): string | null;
    getMarkerRouterId(marker: any): string | null;
    showRouterFilterSelector: boolean;
    showRouterFilter(event?: any): void;
    closeRouterFilter(event?: any): void;
    showIdentityFilterSelector: boolean;
    showIdentityFilter(event?: any): void;
    closeIdentityFilter(event?: any): void;
    showServiceFilterSelector: boolean;
    showServiceFilter(event?: any): void;
    closeServiceFilter(event?: any): void;
    showConnectionStatusFilter(event?: any): void;
    closeConnectionStatusFilter(event?: any): void;
    onConnectionStatusChange(newStatus?: string): void;
    clearFilters(event: any): void;
    onRouterRoleAttributesChange(attributes: any[]): void;
    onIdentityRoleAttributesChange(attributes: any[]): void;
    onIdentityNamedAttributesChange(attributes: any[]): void;
    getIdentityNamedAttributes(filter?: string): void;
    onServiceRoleAttributesChange(attributes: any[]): void;
    onServiceNamedAttributesChange(attributes: any[]): void;
    getServiceNamedAttributes(filter?: string): void;
    checkAppliedFilters(): void;
    reloadMapDataWithFilters(): void;
    filterCircuitsAndRouters(): void;
    openSidePanel(type: 'marker' | 'link' | 'circuit' | 'unlocated' | 'entityList' | 'servicesWithCircuits', data: any): void;
    showUnlocatedEntities(): void;
    showUnlocatedIdentities(): void;
    showUnlocatedRouters(): void;
    showServicesWithActiveCircuits(): void;
    onServicesWithCircuitsSearchChange(search: string): void;
    onUnlocatedIdentitiesSearchChange(search: string): void;
    onUnlocatedRoutersSearchChange(search: string): void;
    showLocatedIdentities(): void;
    showLocatedRouters(): void;
    showAllServices(): void;
    initializeEntityList(entities: any[], type: string): void;
    applyEntityListFilters(): void;
    onEntityListSearchChange(search: string): void;
    onEntityListPageChange(page: number): void;
    onEntityListSortChange(sort: {
        column: string;
        direction: 'asc' | 'desc';
    }): void;
    onEntityListLocationFilterChange(filter: 'all' | 'located' | 'unlocated'): void;
    get entityListTotalPages(): number;
    get entityListPageNumbers(): number[];
    openEntityPreview(entity: any, type: string): void;
    onDragStart(event: DragEvent, entity: any, type: string): void;
    onMapDragOver(event: DragEvent): void;
    onMapDrop(event: DragEvent): void;
    onMapDragLeave(event: DragEvent): void;
    closeSidePanel(): void;
    navigateToDetails(type: string, id: string): void;
    navigateToCircuitEntity(id: string, type: string): void;
    openRouterPanel(router: any): void;
    handleEntityListClick(entity: any): void;
    showEntityListPreview(entity: any, type: 'identity' | 'routers' | 'services'): void;
    closeEntityListPreview(): void;
    openIdentityPanel(identity: any): void;
    openServicePanel(service: any): void;
    openEntityPanel(entityId: string, entityType: string): void;
    parseConnectionType(type: string): string;
    parseEndpoint(endpoint: string): {
        protocol: string;
        address: string;
        port: string;
    };
    updateGeolocationLocal(item: any, lat: number, lng: number, type: string): void;
    handleGeolocationRemoval(item: any, type: string, marker: any): void;
    updateEntityListAfterLocationChange(): void;
    navigateToRoleAttribute(role: string): void;
    getEntityOnlineStatus(item: any): boolean;
    hasUnsavedLocationChanges(item: any): boolean;
    saveLocationChanges(item: any, type: string): Promise<void>;
    saveUnlocatedPreviewEntity(): Promise<void>;
    getEntityCircuits(entityId: string, entityType: string): any[];
    clearActiveCircuits(): void;
    isCircuitSelectionActive(): boolean;
    selectCircuit(circuit: any, isUnlocatedPanel?: boolean): void;
    getCircuitRouters(circuit: any): any[];
    findMarkerByItemId(itemId: string, itemType: string): any;
    updateMarkerIcon(marker: any, isSelected: boolean): void;
    buildCircuitHops(data: any): any[];
    buildCircuitRouters(pathNodes: any[]): any[];
    selectCircuitHop(hop: any, index: number): void;
    selectCircuitRouter(routerId: string, routerType: string): void;
    closeCircuitPreview(): void;
    openCircuitPreview(circuit: any, event?: Event): void;
    private handleDocumentClick;
    onResizerMouseDown(event: MouseEvent): void;
    private onMouseMove;
    onMouseUp(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeolocateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GeolocateComponent, "lib-geolocate", never, {}, {}, never, never, false, never>;
}

declare class MapLegendComponent {
    routersVisible: boolean;
    identitiesVisible: boolean;
    linksVisible: boolean;
    activeCircuitsVisible: boolean;
    clusteringEnabled: boolean;
    isCircuitSelectionActive: boolean;
    routersToggled: EventEmitter<void>;
    identitiesToggled: EventEmitter<void>;
    linksToggled: EventEmitter<void>;
    activeCircuitsToggled: EventEmitter<void>;
    clusteringToggled: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapLegendComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MapLegendComponent, "lib-map-legend", never, { "routersVisible": { "alias": "routersVisible"; "required": false; }; "identitiesVisible": { "alias": "identitiesVisible"; "required": false; }; "linksVisible": { "alias": "linksVisible"; "required": false; }; "activeCircuitsVisible": { "alias": "activeCircuitsVisible"; "required": false; }; "clusteringEnabled": { "alias": "clusteringEnabled"; "required": false; }; "isCircuitSelectionActive": { "alias": "isCircuitSelectionActive"; "required": false; }; }, { "routersToggled": "routersToggled"; "identitiesToggled": "identitiesToggled"; "linksToggled": "linksToggled"; "activeCircuitsToggled": "activeCircuitsToggled"; "clusteringToggled": "clusteringToggled"; }, never, never, false, never>;
}

declare class EntityCountLegendComponent {
    geolocatedIdentities: number;
    unlocatedIdentities: number;
    geolocatedRouters: number;
    unlocatedRouters: number;
    totalServices: number;
    servicesWithActiveCircuits: number;
    totalActiveCircuits: number;
    showLocatedIdentitiesClicked: EventEmitter<void>;
    showUnlocatedIdentitiesClicked: EventEmitter<void>;
    showLocatedRoutersClicked: EventEmitter<void>;
    showUnlocatedRoutersClicked: EventEmitter<void>;
    showAllServicesClicked: EventEmitter<void>;
    showServicesWithActiveCircuitsClicked: EventEmitter<void>;
    get totalIdentities(): number;
    get totalRouters(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityCountLegendComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EntityCountLegendComponent, "lib-entity-count-legend", never, { "geolocatedIdentities": { "alias": "geolocatedIdentities"; "required": false; }; "unlocatedIdentities": { "alias": "unlocatedIdentities"; "required": false; }; "geolocatedRouters": { "alias": "geolocatedRouters"; "required": false; }; "unlocatedRouters": { "alias": "unlocatedRouters"; "required": false; }; "totalServices": { "alias": "totalServices"; "required": false; }; "servicesWithActiveCircuits": { "alias": "servicesWithActiveCircuits"; "required": false; }; "totalActiveCircuits": { "alias": "totalActiveCircuits"; "required": false; }; }, { "showLocatedIdentitiesClicked": "showLocatedIdentitiesClicked"; "showUnlocatedIdentitiesClicked": "showUnlocatedIdentitiesClicked"; "showLocatedRoutersClicked": "showLocatedRoutersClicked"; "showUnlocatedRoutersClicked": "showUnlocatedRoutersClicked"; "showAllServicesClicked": "showAllServicesClicked"; "showServicesWithActiveCircuitsClicked": "showServicesWithActiveCircuitsClicked"; }, never, never, false, never>;
}

declare class CircuitHopsTableComponent implements OnChanges {
    circuitHops: CircuitHop[];
    selectedSegmentIndex: number | null;
    hopSelected: EventEmitter<{
        hop: CircuitHop;
        index: number;
    }>;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CircuitHopsTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CircuitHopsTableComponent, "lib-circuit-hops-table", never, { "circuitHops": { "alias": "circuitHops"; "required": false; }; "selectedSegmentIndex": { "alias": "selectedSegmentIndex"; "required": false; }; }, { "hopSelected": "hopSelected"; }, never, never, false, never>;
}

interface CircuitRouter {
    id: string;
    name: string;
    type: string;
    [key: string]: any;
}
declare class RouterPathTableComponent implements OnChanges {
    private cdr;
    circuitRouters: CircuitRouter[];
    selectedRouterId: string | null;
    routerSelected: EventEmitter<{
        routerId: string;
        routerType: string;
    }>;
    entityPanelOpened: EventEmitter<{
        entityId: string;
        entityType: string;
    }>;
    displayRouters: CircuitRouter[];
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Handle opening entity panel
     */
    onOpenEntityPanel(router: CircuitRouter, event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RouterPathTableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RouterPathTableComponent, "lib-router-path-table", never, { "circuitRouters": { "alias": "circuitRouters"; "required": false; }; "selectedRouterId": { "alias": "selectedRouterId"; "required": false; }; }, { "routerSelected": "routerSelected"; "entityPanelOpened": "entityPanelOpened"; }, never, never, false, never>;
}

declare class GeolocateFilterBarComponent implements OnChanges {
    private cdr;
    selectedRouterAttributes: any[];
    selectedIdentityAttributes: any[];
    selectedIdentityNamedAttributes: any[];
    selectedServiceAttributes: any[];
    selectedServiceNamedAttributes: any[];
    selectedConnectionStatus: string;
    routerRoleAttributes: any[];
    identityRoleAttributes: any[];
    identityNamedAttributes: any[];
    serviceRoleAttributes: any[];
    serviceNamedAttributes: any[];
    filtersApplied: boolean;
    showRouterFilterSelector: boolean;
    showIdentityFilterSelector: boolean;
    showServiceFilterSelector: boolean;
    showConnectionStatusFilterSelector: boolean;
    routerFilterClicked: EventEmitter<Event>;
    identityFilterClicked: EventEmitter<Event>;
    serviceFilterClicked: EventEmitter<Event>;
    connectionStatusFilterClicked: EventEmitter<Event>;
    routerFilterClosed: EventEmitter<Event>;
    identityFilterClosed: EventEmitter<Event>;
    serviceFilterClosed: EventEmitter<Event>;
    connectionStatusFilterClosed: EventEmitter<Event>;
    routerRoleAttributesChanged: EventEmitter<any>;
    identityNamedAttributesChanged: EventEmitter<any>;
    identityRoleAttributesChanged: EventEmitter<any>;
    serviceNamedAttributesChanged: EventEmitter<any>;
    serviceRoleAttributesChanged: EventEmitter<any>;
    connectionStatusChanged: EventEmitter<any>;
    identityFilterChanged: EventEmitter<any>;
    serviceFilterChanged: EventEmitter<any>;
    clearFiltersClicked: EventEmitter<Event>;
    selectedRouterAttributesChange: EventEmitter<any[]>;
    selectedIdentityAttributesChange: EventEmitter<any[]>;
    selectedIdentityNamedAttributesChange: EventEmitter<any[]>;
    selectedServiceAttributesChange: EventEmitter<any[]>;
    selectedServiceNamedAttributesChange: EventEmitter<any[]>;
    selectedConnectionStatusChange: EventEmitter<string>;
    routerFilterSelector: any;
    identityFilterSelector: any;
    serviceFilterSelector: any;
    connectionStatusFilterSelector: any;
    constructor(cdr: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeolocateFilterBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GeolocateFilterBarComponent, "lib-geolocate-filter-bar", never, { "selectedRouterAttributes": { "alias": "selectedRouterAttributes"; "required": false; }; "selectedIdentityAttributes": { "alias": "selectedIdentityAttributes"; "required": false; }; "selectedIdentityNamedAttributes": { "alias": "selectedIdentityNamedAttributes"; "required": false; }; "selectedServiceAttributes": { "alias": "selectedServiceAttributes"; "required": false; }; "selectedServiceNamedAttributes": { "alias": "selectedServiceNamedAttributes"; "required": false; }; "selectedConnectionStatus": { "alias": "selectedConnectionStatus"; "required": false; }; "routerRoleAttributes": { "alias": "routerRoleAttributes"; "required": false; }; "identityRoleAttributes": { "alias": "identityRoleAttributes"; "required": false; }; "identityNamedAttributes": { "alias": "identityNamedAttributes"; "required": false; }; "serviceRoleAttributes": { "alias": "serviceRoleAttributes"; "required": false; }; "serviceNamedAttributes": { "alias": "serviceNamedAttributes"; "required": false; }; "filtersApplied": { "alias": "filtersApplied"; "required": false; }; "showRouterFilterSelector": { "alias": "showRouterFilterSelector"; "required": false; }; "showIdentityFilterSelector": { "alias": "showIdentityFilterSelector"; "required": false; }; "showServiceFilterSelector": { "alias": "showServiceFilterSelector"; "required": false; }; "showConnectionStatusFilterSelector": { "alias": "showConnectionStatusFilterSelector"; "required": false; }; }, { "routerFilterClicked": "routerFilterClicked"; "identityFilterClicked": "identityFilterClicked"; "serviceFilterClicked": "serviceFilterClicked"; "connectionStatusFilterClicked": "connectionStatusFilterClicked"; "routerFilterClosed": "routerFilterClosed"; "identityFilterClosed": "identityFilterClosed"; "serviceFilterClosed": "serviceFilterClosed"; "connectionStatusFilterClosed": "connectionStatusFilterClosed"; "routerRoleAttributesChanged": "routerRoleAttributesChanged"; "identityNamedAttributesChanged": "identityNamedAttributesChanged"; "identityRoleAttributesChanged": "identityRoleAttributesChanged"; "serviceNamedAttributesChanged": "serviceNamedAttributesChanged"; "serviceRoleAttributesChanged": "serviceRoleAttributesChanged"; "connectionStatusChanged": "connectionStatusChanged"; "identityFilterChanged": "identityFilterChanged"; "serviceFilterChanged": "serviceFilterChanged"; "clearFiltersClicked": "clearFiltersClicked"; "selectedRouterAttributesChange": "selectedRouterAttributesChange"; "selectedIdentityAttributesChange": "selectedIdentityAttributesChange"; "selectedIdentityNamedAttributesChange": "selectedIdentityNamedAttributesChange"; "selectedServiceAttributesChange": "selectedServiceAttributesChange"; "selectedServiceNamedAttributesChange": "selectedServiceNamedAttributesChange"; "selectedConnectionStatusChange": "selectedConnectionStatusChange"; }, never, ["*"], false, never>;
}

declare class SidePanelContainerComponent implements OnInit, OnDestroy, OnChanges {
    isOpen: boolean;
    panelType: 'marker' | 'link' | 'circuit' | 'unlocated' | 'entityList' | 'servicesWithCircuits' | null;
    panelData: any;
    sidePanelCircuits: any[];
    selectedCircuit: any;
    selectedCircuitRouters: any[];
    selectedCircuitSegment: any;
    selectedRouterInPath: string | null;
    circuitPreviewEntity: any;
    circuitPreviewEntityType: string;
    entityListType: string;
    entityListSearch: string;
    entityListPage: number;
    entityListPageSize: number;
    entityListTotal: number;
    filteredEntityList: any[];
    entityListPreview: any;
    entityListLocationFilter: 'all' | 'located' | 'unlocated';
    filteredUnlocatedIdentities: any[];
    filteredUnlocatedRouters: any[];
    unlocatedIdentitiesSearch: string;
    unlocatedRoutersSearch: string;
    unlocatedPreviewEntity: any;
    unlocatedPreviewType: string;
    unlocatedPreviewCircuits: any[];
    unlocatedPreviewHasUnsavedLocation: boolean;
    selectedUnlocatedCircuit: any;
    selectedUnlocatedCircuitRouters: any[];
    allCircuits: any[];
    allIdentities: any[];
    allRouters: any[];
    allTerminators: any[];
    servicesWithCircuitsSearch: string;
    closed: EventEmitter<void>;
    circuitSelected: EventEmitter<any>;
    routerInPathSelected: EventEmitter<{
        routerId: string;
        routerType: string;
    }>;
    saveLocationChanges: EventEmitter<{
        item: any;
        type: string;
    }>;
    navigateToDetails: EventEmitter<{
        type: string;
        id: string;
    }>;
    circuitPreviewOpened: EventEmitter<any>;
    roleAttributeNavigated: EventEmitter<string>;
    hopSelected: EventEmitter<{
        hop: any;
        index: number;
    }>;
    routerSelected: EventEmitter<{
        routerId: string;
        routerType: string;
    }>;
    entityClicked: EventEmitter<{
        entityId: string;
        entityType: string;
    }>;
    serviceClicked: EventEmitter<any>;
    circuitPreviewClosed: EventEmitter<void>;
    entityPanelOpened: EventEmitter<{
        entityId: string;
        entityType: string;
    }>;
    routerClicked: EventEmitter<any>;
    entityListSearchChanged: EventEmitter<string>;
    entityListPageChanged: EventEmitter<number>;
    entityListSortChanged: EventEmitter<{
        column: string;
        direction: "asc" | "desc";
    }>;
    entityListLocationFilterChanged: EventEmitter<"all" | "unlocated" | "located">;
    entityListEntityClicked: EventEmitter<any>;
    entityListPreviewClosed: EventEmitter<void>;
    unlocatedIdentitiesSearchChanged: EventEmitter<string>;
    unlocatedRoutersSearchChanged: EventEmitter<string>;
    unlocatedEntityDragStarted: EventEmitter<{
        event: DragEvent;
        entity: any;
        type: string;
    }>;
    unlocatedEntityClicked: EventEmitter<{
        entity: any;
        type: string;
    }>;
    unlocatedPreviewClosed: EventEmitter<void>;
    unlocatedSaveLocationClicked: EventEmitter<void>;
    servicesSearchChanged: EventEmitter<string>;
    sidePanelWidth: number;
    isResizing: boolean;
    minPanelWidth: number;
    maxPanelWidth: number;
    startX: number;
    startWidth: number;
    private mouseMoveSubscription?;
    private mouseUpSubscription?;
    Math: Math;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /**
     * Get header class based on panel type and data
     */
    getHeaderClass(): string;
    /**
     * Get panel title based on panel type and data
     */
    getPanelTitle(): string;
    /**
     * Get title icon class based on panel type
     */
    getTitleIconClass(): string;
    /**
     * Close the side panel
     */
    closePanel(): void;
    /**
     * Handle resize mouse down
     */
    onResizerMouseDown(event: MouseEvent): void;
    /**
     * Handle mouse move during resize
     */
    private onMouseMove;
    /**
     * Handle mouse up after resize
     */
    private onMouseUp;
    /**
     * Update CSS variable for panel width
     */
    private updatePanelWidth;
    /**
     * Cleanup mouse event listeners
     */
    private cleanupMouseListeners;
    static ɵfac: i0.ɵɵFactoryDeclaration<SidePanelContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SidePanelContainerComponent, "lib-side-panel-container", never, { "isOpen": { "alias": "isOpen"; "required": false; }; "panelType": { "alias": "panelType"; "required": false; }; "panelData": { "alias": "panelData"; "required": false; }; "sidePanelCircuits": { "alias": "sidePanelCircuits"; "required": false; }; "selectedCircuit": { "alias": "selectedCircuit"; "required": false; }; "selectedCircuitRouters": { "alias": "selectedCircuitRouters"; "required": false; }; "selectedCircuitSegment": { "alias": "selectedCircuitSegment"; "required": false; }; "selectedRouterInPath": { "alias": "selectedRouterInPath"; "required": false; }; "circuitPreviewEntity": { "alias": "circuitPreviewEntity"; "required": false; }; "circuitPreviewEntityType": { "alias": "circuitPreviewEntityType"; "required": false; }; "entityListType": { "alias": "entityListType"; "required": false; }; "entityListSearch": { "alias": "entityListSearch"; "required": false; }; "entityListPage": { "alias": "entityListPage"; "required": false; }; "entityListPageSize": { "alias": "entityListPageSize"; "required": false; }; "entityListTotal": { "alias": "entityListTotal"; "required": false; }; "filteredEntityList": { "alias": "filteredEntityList"; "required": false; }; "entityListPreview": { "alias": "entityListPreview"; "required": false; }; "entityListLocationFilter": { "alias": "entityListLocationFilter"; "required": false; }; "filteredUnlocatedIdentities": { "alias": "filteredUnlocatedIdentities"; "required": false; }; "filteredUnlocatedRouters": { "alias": "filteredUnlocatedRouters"; "required": false; }; "unlocatedIdentitiesSearch": { "alias": "unlocatedIdentitiesSearch"; "required": false; }; "unlocatedRoutersSearch": { "alias": "unlocatedRoutersSearch"; "required": false; }; "unlocatedPreviewEntity": { "alias": "unlocatedPreviewEntity"; "required": false; }; "unlocatedPreviewType": { "alias": "unlocatedPreviewType"; "required": false; }; "unlocatedPreviewCircuits": { "alias": "unlocatedPreviewCircuits"; "required": false; }; "unlocatedPreviewHasUnsavedLocation": { "alias": "unlocatedPreviewHasUnsavedLocation"; "required": false; }; "selectedUnlocatedCircuit": { "alias": "selectedUnlocatedCircuit"; "required": false; }; "selectedUnlocatedCircuitRouters": { "alias": "selectedUnlocatedCircuitRouters"; "required": false; }; "allCircuits": { "alias": "allCircuits"; "required": false; }; "allIdentities": { "alias": "allIdentities"; "required": false; }; "allRouters": { "alias": "allRouters"; "required": false; }; "allTerminators": { "alias": "allTerminators"; "required": false; }; "servicesWithCircuitsSearch": { "alias": "servicesWithCircuitsSearch"; "required": false; }; }, { "closed": "closed"; "circuitSelected": "circuitSelected"; "routerInPathSelected": "routerInPathSelected"; "saveLocationChanges": "saveLocationChanges"; "navigateToDetails": "navigateToDetails"; "circuitPreviewOpened": "circuitPreviewOpened"; "roleAttributeNavigated": "roleAttributeNavigated"; "hopSelected": "hopSelected"; "routerSelected": "routerSelected"; "entityClicked": "entityClicked"; "serviceClicked": "serviceClicked"; "circuitPreviewClosed": "circuitPreviewClosed"; "entityPanelOpened": "entityPanelOpened"; "routerClicked": "routerClicked"; "entityListSearchChanged": "entityListSearchChanged"; "entityListPageChanged": "entityListPageChanged"; "entityListSortChanged": "entityListSortChanged"; "entityListLocationFilterChanged": "entityListLocationFilterChanged"; "entityListEntityClicked": "entityListEntityClicked"; "entityListPreviewClosed": "entityListPreviewClosed"; "unlocatedIdentitiesSearchChanged": "unlocatedIdentitiesSearchChanged"; "unlocatedRoutersSearchChanged": "unlocatedRoutersSearchChanged"; "unlocatedEntityDragStarted": "unlocatedEntityDragStarted"; "unlocatedEntityClicked": "unlocatedEntityClicked"; "unlocatedPreviewClosed": "unlocatedPreviewClosed"; "unlocatedSaveLocationClicked": "unlocatedSaveLocationClicked"; "servicesSearchChanged": "servicesSearchChanged"; }, never, never, false, never>;
}

interface ServiceGroup$3 {
    serviceName: string;
    serviceId: string;
    circuits: any[];
    expanded: boolean;
    sortBy?: 'created';
    sortDirection?: 'asc' | 'desc';
}
declare class MarkerPanelComponent implements OnChanges {
    private circuitCalculationService;
    markerData: any;
    circuits: any[];
    selectedCircuit: any;
    selectedCircuitRouters: any[];
    selectedRouterInPath: string | null;
    allIdentities: any[];
    allRouters: any[];
    allTerminators: any[];
    circuitSelected: EventEmitter<any>;
    routerInPathSelected: EventEmitter<{
        routerId: string;
        routerType: string;
    }>;
    saveLocationChanges: EventEmitter<{
        item: any;
        type: string;
    }>;
    navigateToDetails: EventEmitter<{
        type: string;
        id: string;
    }>;
    circuitPreviewOpened: EventEmitter<any>;
    roleAttributeNavigated: EventEmitter<string>;
    panelClosed: EventEmitter<void>;
    serviceGroups: ServiceGroup$3[];
    constructor(circuitCalculationService: CircuitCalculationService);
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Get entity online status
     */
    getEntityOnlineStatus(entity: any): boolean;
    /**
     * Check if entity has unsaved location changes
     */
    hasUnsavedLocationChanges(item: any): boolean;
    /**
     * Select a circuit
     */
    onCircuitSelect(circuit: any, event?: MouseEvent): void;
    /**
     * Open circuit preview (detail view)
     */
    onCircuitPreviewOpen(circuit: any, event: MouseEvent): void;
    /**
     * Select a router in the circuit path
     */
    onRouterInPathSelect(routerId: string, routerType: string): void;
    /**
     * Save location changes for the entity
     */
    onSaveLocationChanges(): void;
    /**
     * Navigate to entity details page
     */
    onNavigateToDetails(): void;
    /**
     * Close the marker panel
     */
    onCancel(): void;
    /**
     * Navigate to role attribute
     */
    onRoleAttributeClick(role: string): void;
    /**
     * Update service groups - group circuits by service and apply filtering
     */
    updateServiceGroups(): void;
    /**
     * Toggle service group expansion
     */
    toggleGroup(group: ServiceGroup$3, event?: Event): void;
    /**
     * Toggle sort for a service group
     */
    toggleSort(group: ServiceGroup$3): void;
    /**
     * Get entity name and type from ID
     */
    getEntityInfo(entityId: string): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Compute client entity info from circuit (called once during data processing)
     */
    private computeClientInfo;
    /**
     * Compute host entity info from circuit (called once during data processing)
     */
    private computeHostInfo;
    /**
     * Get cached client entity info from circuit (used in templates)
     */
    getClientInfo(circuit: any): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get cached host entity info from circuit (used in templates)
     */
    getHostInfo(circuit: any): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get sorted circuits for a group - dual sort with created date as primary when active
     */
    getSortedCircuits(group: ServiceGroup$3): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<MarkerPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MarkerPanelComponent, "lib-marker-panel", never, { "markerData": { "alias": "markerData"; "required": false; }; "circuits": { "alias": "circuits"; "required": false; }; "selectedCircuit": { "alias": "selectedCircuit"; "required": false; }; "selectedCircuitRouters": { "alias": "selectedCircuitRouters"; "required": false; }; "selectedRouterInPath": { "alias": "selectedRouterInPath"; "required": false; }; "allIdentities": { "alias": "allIdentities"; "required": false; }; "allRouters": { "alias": "allRouters"; "required": false; }; "allTerminators": { "alias": "allTerminators"; "required": false; }; }, { "circuitSelected": "circuitSelected"; "routerInPathSelected": "routerInPathSelected"; "saveLocationChanges": "saveLocationChanges"; "navigateToDetails": "navigateToDetails"; "circuitPreviewOpened": "circuitPreviewOpened"; "roleAttributeNavigated": "roleAttributeNavigated"; "panelClosed": "panelClosed"; }, never, never, false, never>;
}

declare class LinkPanelComponent {
    linkData: any;
    routerClicked: EventEmitter<any>;
    /**
     * Parse connection type
     */
    parseConnectionType(type: string): string;
    /**
     * Parse connection endpoint (e.g., "tls:10.0.0.1:443")
     */
    parseEndpoint(endpoint: string): {
        protocol: string;
        address: string;
        port: string;
    };
    /**
     * Handle router click
     */
    onRouterClick(router: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LinkPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LinkPanelComponent, "lib-link-panel", never, { "linkData": { "alias": "linkData"; "required": false; }; }, { "routerClicked": "routerClicked"; }, never, never, false, never>;
}

declare class CircuitPanelComponent {
    circuitData: any;
    selectedSegmentIndex: number | null;
    selectedRouterId: string | null;
    previewEntity: any;
    previewEntityType: string;
    hopSelected: EventEmitter<{
        hop: any;
        index: number;
    }>;
    routerSelected: EventEmitter<{
        routerId: string;
        routerType: string;
    }>;
    entityClicked: EventEmitter<{
        entityId: string;
        entityType: string;
    }>;
    serviceClicked: EventEmitter<any>;
    previewClosed: EventEmitter<void>;
    navigateToDetails: EventEmitter<{
        type: string;
        id: string;
    }>;
    entityPanelOpened: EventEmitter<{
        entityId: string;
        entityType: string;
    }>;
    /**
     * Handle hop selection from circuit hops table
     */
    onHopSelected(event: {
        hop: any;
        index: number;
    }): void;
    /**
     * Handle router selection from router path table
     */
    onRouterSelected(event: {
        routerId: string;
        routerType: string;
    }): void;
    /**
     * Handle entity click (identity/router in circuit endpoints)
     */
    onEntityClick(entityId: string, entityType: string): void;
    /**
     * Handle service click
     */
    onServiceClick(service: any): void;
    /**
     * Close the entity preview
     */
    closePreview(): void;
    /**
     * Handle navigate to details from router path table
     */
    onNavigateToDetails(event: {
        type: string;
        id: string;
    }): void;
    /**
     * Handle entity panel opening from router path table or preview
     */
    onEntityPanelOpened(event: {
        entityId: string;
        entityType: string;
    }): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CircuitPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CircuitPanelComponent, "lib-circuit-panel", never, { "circuitData": { "alias": "circuitData"; "required": false; }; "selectedSegmentIndex": { "alias": "selectedSegmentIndex"; "required": false; }; "selectedRouterId": { "alias": "selectedRouterId"; "required": false; }; "previewEntity": { "alias": "previewEntity"; "required": false; }; "previewEntityType": { "alias": "previewEntityType"; "required": false; }; }, { "hopSelected": "hopSelected"; "routerSelected": "routerSelected"; "entityClicked": "entityClicked"; "serviceClicked": "serviceClicked"; "previewClosed": "previewClosed"; "navigateToDetails": "navigateToDetails"; "entityPanelOpened": "entityPanelOpened"; }, never, never, false, never>;
}

interface ServiceGroup$2 {
    serviceName: string;
    serviceId: string;
    circuits: any[];
    expanded: boolean;
    sortBy?: 'created';
    sortDirection?: 'asc' | 'desc';
}
declare class EntityListPanelComponent implements OnChanges {
    entityType: string;
    entities: any[];
    currentPage: number;
    pageSize: number;
    totalEntities: number;
    searchTerm: string;
    previewEntity: any;
    previewCircuits: any[];
    selectedCircuit: any;
    selectedCircuitRouters: any[];
    selectedRouterInPath: string | null;
    Math: any;
    allIdentities: any[];
    allRouters: any[];
    locationFilter: 'all' | 'located' | 'unlocated';
    searchChanged: EventEmitter<string>;
    pageChanged: EventEmitter<number>;
    locationFilterChanged: EventEmitter<"all" | "unlocated" | "located">;
    entityClicked: EventEmitter<any>;
    previewClosed: EventEmitter<void>;
    circuitSelected: EventEmitter<any>;
    routerInPathSelected: EventEmitter<{
        routerId: string;
        routerType: string;
    }>;
    saveLocationChanges: EventEmitter<{
        item: any;
        type: string;
    }>;
    navigateToDetails: EventEmitter<{
        type: string;
        id: string;
    }>;
    circuitPreviewOpened: EventEmitter<any>;
    roleAttributeNavigated: EventEmitter<string>;
    sortChanged: EventEmitter<{
        column: string;
        direction: "asc" | "desc";
    }>;
    entityDragStarted: EventEmitter<{
        event: DragEvent;
        entity: any;
        type: string;
    }>;
    sortColumn: string;
    sortDirection: 'asc' | 'desc';
    serviceGroups: ServiceGroup$2[];
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Get total pages
     */
    get totalPages(): number;
    /**
     * Toggle sort for a column
     */
    toggleSort(column: string): void;
    /**
     * Get page numbers for pagination display
     */
    get pageNumbers(): number[];
    /**
     * Handle search input change
     */
    onSearchChange(search: string): void;
    /**
     * Handle location filter change
     */
    onLocationFilterChange(filter: 'all' | 'located' | 'unlocated'): void;
    /**
     * Handle page change
     */
    onPageChange(page: number): void;
    /**
     * Handle drag start for unlocated entities
     */
    onDragStart(event: DragEvent, entity: any): void;
    /**
     * Handle entity row click
     */
    onEntityClick(entity: any): void;
    /**
     * Close preview pane
     */
    onPreviewClose(): void;
    /**
     * Get entity online status
     */
    getEntityOnlineStatus(entity: any): boolean;
    /**
     * Check if entity has unsaved location changes
     */
    hasUnsavedLocationChanges(item: any): boolean;
    /**
     * Select a circuit
     */
    onCircuitSelect(circuit: any, event?: MouseEvent): void;
    /**
     * Open circuit preview
     */
    onCircuitPreviewOpen(circuit: any, event: MouseEvent): void;
    /**
     * Select router in path
     */
    onRouterInPathSelect(routerId: string, routerType: string): void;
    /**
     * Save location changes
     */
    onSaveLocationChanges(): void;
    /**
     * Navigate to details
     */
    onNavigateToDetails(): void;
    /**
     * Navigate to role attribute
     */
    onRoleAttributeClick(role: string, event?: Event): void;
    /**
     * Update service groups - group circuits by service and apply filtering
     */
    updateServiceGroups(): void;
    /**
     * Toggle service group expansion
     */
    toggleGroup(group: ServiceGroup$2, event?: Event): void;
    /**
     * Toggle sort for a service group
     */
    toggleCircuitSort(group: ServiceGroup$2): void;
    /**
     * Get entity name and type from ID
     */
    getEntityInfo(entityId: string): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Compute client entity info from circuit (called once during data processing)
     */
    private computeClientInfo;
    /**
     * Compute host entity info from circuit (called once during data processing)
     */
    private computeHostInfo;
    /**
     * Get cached client entity info from circuit (used in templates)
     */
    getClientInfo(circuit: any): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get cached host entity info from circuit (used in templates)
     */
    getHostInfo(circuit: any): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get sorted circuits for a group - dual sort with created date as primary when active
     */
    getSortedCircuits(group: ServiceGroup$2): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<EntityListPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EntityListPanelComponent, "lib-entity-list-panel", never, { "entityType": { "alias": "entityType"; "required": false; }; "entities": { "alias": "entities"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "totalEntities": { "alias": "totalEntities"; "required": false; }; "searchTerm": { "alias": "searchTerm"; "required": false; }; "previewEntity": { "alias": "previewEntity"; "required": false; }; "previewCircuits": { "alias": "previewCircuits"; "required": false; }; "selectedCircuit": { "alias": "selectedCircuit"; "required": false; }; "selectedCircuitRouters": { "alias": "selectedCircuitRouters"; "required": false; }; "selectedRouterInPath": { "alias": "selectedRouterInPath"; "required": false; }; "Math": { "alias": "Math"; "required": false; }; "allIdentities": { "alias": "allIdentities"; "required": false; }; "allRouters": { "alias": "allRouters"; "required": false; }; "locationFilter": { "alias": "locationFilter"; "required": false; }; }, { "searchChanged": "searchChanged"; "pageChanged": "pageChanged"; "locationFilterChanged": "locationFilterChanged"; "entityClicked": "entityClicked"; "previewClosed": "previewClosed"; "circuitSelected": "circuitSelected"; "routerInPathSelected": "routerInPathSelected"; "saveLocationChanges": "saveLocationChanges"; "navigateToDetails": "navigateToDetails"; "circuitPreviewOpened": "circuitPreviewOpened"; "roleAttributeNavigated": "roleAttributeNavigated"; "sortChanged": "sortChanged"; "entityDragStarted": "entityDragStarted"; }, never, never, false, never>;
}

interface ServiceGroup$1 {
    serviceName: string;
    serviceId: string;
    circuits: any[];
    expanded: boolean;
    sortBy?: 'created';
    sortDirection?: 'asc' | 'desc';
}
declare class UnlocatedPanelComponent implements OnChanges {
    unlocatedData: any;
    filteredIdentities: any[];
    filteredRouters: any[];
    identitiesSearch: string;
    routersSearch: string;
    previewEntity: any;
    previewType: string;
    previewCircuits: any[];
    previewHasUnsavedLocation: boolean;
    selectedCircuit: any;
    selectedCircuitRouters: any[];
    selectedRouterInPath: string | null;
    allIdentities: any[];
    allRouters: any[];
    identitiesSearchChanged: EventEmitter<string>;
    routersSearchChanged: EventEmitter<string>;
    entityDragStarted: EventEmitter<{
        event: DragEvent;
        entity: any;
        type: string;
    }>;
    entityClicked: EventEmitter<{
        entity: any;
        type: string;
    }>;
    previewClosed: EventEmitter<void>;
    saveLocationClicked: EventEmitter<void>;
    circuitSelected: EventEmitter<any>;
    routerInPathSelected: EventEmitter<{
        routerId: string;
        routerType: string;
    }>;
    navigateToDetails: EventEmitter<{
        type: string;
        id: string;
    }>;
    circuitPreviewOpened: EventEmitter<any>;
    roleAttributeNavigated: EventEmitter<string>;
    serviceGroups: ServiceGroup$1[];
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Handle identities search change
     */
    onIdentitiesSearchChange(search: string): void;
    /**
     * Handle routers search change
     */
    onRoutersSearchChange(search: string): void;
    /**
     * Handle drag start
     */
    onDragStart(event: DragEvent, entity: any, type: string): void;
    /**
     * Handle entity click
     */
    onEntityClick(entity: any, type: string): void;
    /**
     * Close preview
     */
    onPreviewClose(): void;
    /**
     * Save location
     */
    onSaveLocation(): void;
    /**
     * Get entity online status
     */
    getEntityOnlineStatus(entity: any): boolean;
    /**
     * Select a circuit
     */
    onCircuitSelect(circuit: any, event?: MouseEvent): void;
    /**
     * Open circuit preview
     */
    onCircuitPreviewOpen(circuit: any, event: MouseEvent): void;
    /**
     * Select router in path
     */
    onRouterInPathSelect(routerId: string, routerType: string): void;
    /**
     * Navigate to details
     */
    onNavigateToDetails(): void;
    /**
     * Navigate to role attribute
     */
    onRoleAttributeClick(role: string, event?: Event): void;
    /**
     * Update service groups - group circuits by service and apply filtering
     */
    updateServiceGroups(): void;
    /**
     * Toggle service group expansion
     */
    toggleGroup(group: ServiceGroup$1, event?: Event): void;
    /**
     * Toggle sort for a service group
     */
    toggleCircuitSort(group: ServiceGroup$1): void;
    /**
     * Get entity name and type from ID
     */
    getEntityInfo(entityId: string): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get client entity info from circuit
     */
    getClientInfo(circuit: any): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get host entity info from circuit
     */
    getHostInfo(circuit: any): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get sorted circuits for a group - dual sort with created date as primary when active
     */
    getSortedCircuits(group: ServiceGroup$1): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<UnlocatedPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UnlocatedPanelComponent, "lib-unlocated-panel", never, { "unlocatedData": { "alias": "unlocatedData"; "required": false; }; "filteredIdentities": { "alias": "filteredIdentities"; "required": false; }; "filteredRouters": { "alias": "filteredRouters"; "required": false; }; "identitiesSearch": { "alias": "identitiesSearch"; "required": false; }; "routersSearch": { "alias": "routersSearch"; "required": false; }; "previewEntity": { "alias": "previewEntity"; "required": false; }; "previewType": { "alias": "previewType"; "required": false; }; "previewCircuits": { "alias": "previewCircuits"; "required": false; }; "previewHasUnsavedLocation": { "alias": "previewHasUnsavedLocation"; "required": false; }; "selectedCircuit": { "alias": "selectedCircuit"; "required": false; }; "selectedCircuitRouters": { "alias": "selectedCircuitRouters"; "required": false; }; "selectedRouterInPath": { "alias": "selectedRouterInPath"; "required": false; }; "allIdentities": { "alias": "allIdentities"; "required": false; }; "allRouters": { "alias": "allRouters"; "required": false; }; }, { "identitiesSearchChanged": "identitiesSearchChanged"; "routersSearchChanged": "routersSearchChanged"; "entityDragStarted": "entityDragStarted"; "entityClicked": "entityClicked"; "previewClosed": "previewClosed"; "saveLocationClicked": "saveLocationClicked"; "circuitSelected": "circuitSelected"; "routerInPathSelected": "routerInPathSelected"; "navigateToDetails": "navigateToDetails"; "circuitPreviewOpened": "circuitPreviewOpened"; "roleAttributeNavigated": "roleAttributeNavigated"; }, never, never, false, never>;
}

interface ServiceGroup {
    serviceName: string;
    serviceId: string;
    circuits: any[];
    expanded: boolean;
    sortBy?: 'created';
    sortDirection?: 'asc' | 'desc';
}
declare class ServicesWithCircuitsPanelComponent implements OnChanges {
    allCircuits: any[];
    allIdentities: any[];
    allRouters: any[];
    searchTerm: string;
    selectedCircuit: any;
    searchChanged: EventEmitter<string>;
    circuitSelected: EventEmitter<any>;
    circuitPreviewOpened: EventEmitter<any>;
    serviceGroups: ServiceGroup[];
    totalCircuits: number;
    previewCircuit: any;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Update service groups - group circuits by service and apply search filter
     */
    updateServiceGroups(): void;
    /**
     * Handle search input change
     */
    onSearchChange(search: string): void;
    /**
     * Handle circuit row click - opens preview and displays on map
     */
    onCircuitClick(circuit: any, event?: Event): void;
    /**
     * Close the circuit preview
     */
    closePreview(): void;
    /**
     * View full circuit details - opens full circuit panel
     */
    viewFullCircuitDetails(): void;
    /**
     * Toggle service group expansion
     */
    toggleGroup(group: ServiceGroup, event?: Event): void;
    /**
     * Get entity name and type from ID
     */
    getEntityInfo(entityId: string): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Compute client entity info from circuit (called once during data processing)
     */
    private computeClientInfo;
    /**
     * Compute host entity info from circuit (called once during data processing)
     */
    private computeHostInfo;
    /**
     * Get cached client entity info from circuit (used in templates)
     */
    getClientInfo(circuit: any): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get cached host entity info from circuit (used in templates)
     */
    getHostInfo(circuit: any): {
        name: string;
        type: 'identity' | 'router';
    };
    /**
     * Get total circuits across all groups
     */
    getTotalCircuitsInGroups(): number;
    /**
     * Toggle sort for a service group
     */
    toggleSort(group: ServiceGroup): void;
    /**
     * Get sorted circuits for a group - always dual sort by client name first, then by created date
     */
    getSortedCircuits(group: ServiceGroup): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ServicesWithCircuitsPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ServicesWithCircuitsPanelComponent, "lib-services-with-circuits-panel", never, { "allCircuits": { "alias": "allCircuits"; "required": false; }; "allIdentities": { "alias": "allIdentities"; "required": false; }; "allRouters": { "alias": "allRouters"; "required": false; }; "searchTerm": { "alias": "searchTerm"; "required": false; }; "selectedCircuit": { "alias": "selectedCircuit"; "required": false; }; }, { "searchChanged": "searchChanged"; "circuitSelected": "circuitSelected"; "circuitPreviewOpened": "circuitPreviewOpened"; }, never, never, false, never>;
}

interface HAController {
    url: string;
    name: string;
    isOnline: boolean;
    lastHealthCheck: Date | null;
    lastResponseTime: number | null;
    sessionToken: string | null;
}
interface HAClusterStatus {
    enabled: boolean;
    controllers: HAController[];
    onlineCount: number;
    totalCount: number;
}
declare class HAControllerService {
    private httpClient;
    private _clusterStatus$;
    clusterStatus$: Observable<HAClusterStatus>;
    private healthCheckSubscription;
    private readonly HEALTH_CHECK_INTERVAL;
    constructor(httpClient: HttpClient);
    /**
     * Initialize HA cluster with discovered controllers
     */
    initializeCluster(controllers: HAController[]): void;
    /**
     * Add a controller to the HA cluster
     */
    addController(controller: HAController): void;
    /**
     * Remove a controller from the HA cluster
     */
    removeController(controllerUrl: string): void;
    /**
     * Update session token for a controller
     */
    updateSessionToken(controllerUrl: string, token: string): void;
    /**
     * Get session token for a specific controller
     */
    getSessionToken(controllerUrl: string): string | null;
    /**
     * Get all online controllers
     */
    getOnlineControllers(): HAController[];
    /**
     * Get all controllers with valid sessions
     */
    getControllersWithSessions(): HAController[];
    /**
     * Check if HA is enabled
     */
    isHAEnabled(): boolean;
    /**
     * Perform health check on a single controller
     */
    private checkControllerHealth;
    /**
     * Perform health checks on all controllers
     */
    private performHealthChecks;
    /**
     * Start periodic health checks
     */
    private startHealthChecks;
    /**
     * Stop periodic health checks
     */
    private stopHealthChecks;
    /**
     * Reset HA cluster (disable and clear all controllers)
     */
    reset(): void;
    /**
     * Cleanup on service destruction
     */
    ngOnDestroy(): void;
    /**
     * Save cluster status to localStorage
     */
    private saveClusterStatus;
    /**
     * Restore cluster status from localStorage
     */
    private restoreClusterStatus;
    /**
     * Clear cluster status from localStorage
     */
    private clearClusterStatus;
    static ɵfac: i0.ɵɵFactoryDeclaration<HAControllerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HAControllerService>;
}

declare class HaStatusIndicatorComponent implements OnInit, OnDestroy {
    private haControllerService;
    clusterStatus: HAClusterStatus | null;
    isExpanded: boolean;
    private subscription;
    constructor(haControllerService: HAControllerService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    toggleExpanded(): void;
    getControllerStatusClass(controller: HAController): string;
    getControllerIcon(controller: HAController): string;
    formatResponseTime(controller: HAController): string;
    formatLastCheck(controller: HAController): string;
    get statusSummary(): string;
    get statusIcon(): string;
    get statusClass(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<HaStatusIndicatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HaStatusIndicatorComponent, "lib-ha-status-indicator", never, {}, {}, never, never, false, never>;
}

declare class AttributesComponent implements OnInit, OnDestroy {
    private zitiDataService;
    private route;
    attributes: any[];
    identities: any[];
    services: any[];
    edgeRouters: any[];
    postureChecks: any[];
    identityAttributes: any[];
    edgeRouterAttributes: any[];
    serviceAttributes: any[];
    selectedAttribute: any;
    private subscription;
    constructor(zitiDataService: ZitiDataService, route: ActivatedRoute);
    ngOnInit(): void;
    loadData(): void;
    attributesLoaded(): void;
    calculateAttributes(): void;
    countOccurrences(items: any[], attribute: string): number;
    getAssociatedItems(items: any[], attribute: string): string;
    editAttribute(attributeName: string): void;
    closeModal(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AttributesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AttributesComponent, "lib-attributes", never, {}, {}, never, never, false, never>;
}

declare class SideNavigatorComponent implements OnInit, OnDestroy {
    private router;
    currentNav: any;
    private haControllerService;
    version: string;
    currentNetwork: any;
    navExpanded: boolean;
    navHidden: boolean;
    hideMenuNavBar: boolean;
    betaFeaturesEnabled: boolean;
    isHAEnabled: boolean;
    private routerSubscription?;
    private haSubscription?;
    private selectedNavItem;
    constructor(router: Router, currentNav: any, haControllerService: HAControllerService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private updateSelectedNavItem;
    private getRouteMatchScore;
    private calculateMatchScore;
    navItemSelected(navItem: any): boolean;
    isNavItemDisabled(navItem: any): void;
    doNavAction(event: any, navItem: any): void;
    showExpandCollapseIcon: boolean;
    showExpandCollapseIconChange: EventEmitter<boolean>;
    showExpandCollapse(event: any): void;
    hideExpandCollapse(event: any): void;
    toggleNavigationExpanded(event: any): void;
    get expandCollapseIconVisible(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SideNavigatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SideNavigatorComponent, "lib-side-navigator", never, { "version": { "alias": "version"; "required": false; }; }, {}, never, never, false, never>;
}

declare class HeaderBarComponent {
    private router;
    private dialogForm;
    private loginService;
    private route;
    headerTitle: string;
    alertsOpen: boolean;
    supportOpen: boolean;
    profileOpen: boolean;
    profilePhoto: string;
    username: string;
    dialogRef: any;
    constructor(router: Router, dialogForm: MatDialog, loginService: LoginServiceClass, route: ActivatedRoute);
    openQuickAdd(): void;
    openAlerts(): void;
    openSupport(): void;
    getPrimaryPathSegmentReliably(): string;
    openProfileMenu(): void;
    closeProfileMenu(): void;
    confirmLogout(): void;
    goToDashboard(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderBarComponent, "lib-header-bar", never, { "headerTitle": { "alias": "headerTitle"; "required": false; }; }, {}, never, never, false, never>;
}

declare class QuickAddComponent {
    private dialogRef;
    data: any;
    private router;
    constructor(dialogRef: MatDialogRef<QuickAddComponent>, data: any, router: Router);
    identityLinkClicked(event: any): void;
    serviceLinkClicked(event: any): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<QuickAddComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<QuickAddComponent, "lib-quick-add", never, {}, {}, never, never, false, never>;
}

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

declare class DateTimePickerComponent implements ControlValueAccessor {
    minDate: Date | null;
    placeholder: string;
    displayFormat: string;
    ariaLabel: string;
    closeOnDateSelect: boolean;
    /** CSS length, e.g. "22rem" or "420px" */
    panelWidth: string;
    open: boolean;
    disabled: boolean;
    value: Date;
    hour: number;
    minute: number;
    private onChange;
    private onTouched;
    get displayValue(): string;
    writeValue(value: Date | null): void;
    registerOnChange(fn: (value: Date | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    toggle(): void;
    close(): void;
    onDateSelected(newDate: Date | null): void;
    adjustHour(delta: number): void;
    adjustMinute(delta: number): void;
    twoDigit(n: number): string;
    private syncTimeFromDate;
    private applyTimeToDate;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimePickerComponent, "lib-date-time-picker", never, { "minDate": { "alias": "minDate"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "closeOnDateSelect": { "alias": "closeOnDateSelect"; "required": false; }; "panelWidth": { "alias": "panelWidth"; "required": false; }; }, {}, never, never, true, never>;
}

declare class GrowlerComponent implements OnInit, OnDestroy {
    private growlerService;
    title: string;
    subtitle: string;
    level: string;
    content: string;
    show: boolean;
    private growlerServiceSub;
    constructor(growlerService: GrowlerService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private showGrowler;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrowlerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrowlerComponent, "lib-growler", never, { "title": { "alias": "title"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "level": { "alias": "level"; "required": false; }; "content": { "alias": "content"; "required": false; }; "show": { "alias": "show"; "required": false; }; }, {}, never, never, false, never>;
}

declare class GrowlerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<GrowlerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<GrowlerModule, [typeof GrowlerComponent], [typeof i2.CommonModule, typeof i3.FormsModule], [typeof GrowlerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<GrowlerModule>;
}

declare function playerFactory(): Promise<typeof lottie_web>;
declare class OpenZitiConsoleLibModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenZitiConsoleLibModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OpenZitiConsoleLibModule, [typeof SafePipe, typeof ExtendableComponent, typeof StringInputComponent, typeof NumberInputComponent, typeof BooleanToggleInputComponent, typeof ObjectComponent, typeof SelectorInputComponent, typeof TextListInputComponent, typeof ChipsInputComponent, typeof CheckboxListInputComponent, typeof ProtocolAddressPortInputComponent, typeof SideNavbarComponent, typeof PasswordInputComponent, typeof TerminatorFormComponent, typeof ConfigurationsPageComponent, typeof ConfigTypesPageComponent, typeof ConfigTypeFormComponent, typeof ListPageHeaderComponent, typeof FilterBarComponent, typeof ListPageFormComponent, typeof IdentitiesPageComponent, typeof EdgeRoutersPageComponent, typeof TransitRoutersPageComponent, typeof DataTableComponent, typeof TableCellSelectComponent, typeof TableColumnSelectComponent, typeof TableCellMenuComponent, typeof TableColumnMenuComponent, typeof TableColumnDefaultComponent, typeof TableColumnFilterComponent, typeof IdentityFormComponent, typeof EdgeRouterFormComponent, typeof TransitRouterFormComponent, typeof HiddenColumnsBarComponent, typeof ConfirmComponent, typeof NoItemsComponent, typeof SideModalComponent, typeof FormHeaderComponent, typeof FormFieldContainerComponent, typeof PreviewListComponent, typeof LoadingIndicatorComponent, typeof FormFieldToggleComponent, typeof JsonViewComponent, typeof TagSelectorComponent, typeof QrCodeComponent, typeof TableCellTokenComponent, typeof OSTooltipComponent, typeof SDKTooltipComponent, typeof OverridesComponent, typeof ResetEnrollmentComponent, typeof IdentityServicePathComponent, typeof NetworkVisualizerComponent, typeof CustomTagsComponent, typeof ServicesPageComponent, typeof ServiceFormComponent, typeof PortRangesComponent, typeof ForwardingConfigComponent, typeof CardListComponent, typeof SimpleServiceComponent, typeof CardComponent, typeof CreationSummaryDialogComponent, typeof ConfigEditorComponent, typeof ServicePoliciesPageComponent, typeof ServicePolicyFormComponent, typeof EdgeRouterPoliciesPageComponent, typeof EdgeRouterPolicyFormComponent, typeof MultiActionButtonComponent, typeof TableCellNameComponent, typeof ServiceEdgeRouterPoliciesPageComponent, typeof ServiceEdgeRouterPolicyFormComponent, typeof TerminatorsPageComponent, typeof ConfigurationFormComponent, typeof JwtSignersPageComponent, typeof JwtSignerFormComponent, typeof AuthPoliciesPageComponent, typeof AuthPolicyFormComponent, typeof PreviewSelectionsComponent, typeof CertificateAuthoritiesPageComponent, typeof CertificateAuthorityFormComponent, typeof VerifyCertificateComponent, typeof LoginDialogComponent, typeof PostureChecksPageComponent, typeof PostureCheckFormComponent, typeof SessionsPageComponent, typeof SessionFormComponent, typeof APISessionsPageComponent, typeof APISessionFormComponent, typeof CallbackComponent, typeof ProgressMeterComponent, typeof ProgressWizardComponent, typeof SettingsComponent, typeof ProfileComponent, typeof GeolocateComponent, typeof MapLegendComponent, typeof EntityCountLegendComponent, typeof CircuitHopsTableComponent, typeof RouterPathTableComponent, typeof GeolocateFilterBarComponent, typeof SidePanelContainerComponent, typeof MarkerPanelComponent, typeof LinkPanelComponent, typeof CircuitPanelComponent, typeof EntityListPanelComponent, typeof UnlocatedPanelComponent, typeof ServicesWithCircuitsPanelComponent, typeof HaStatusIndicatorComponent, typeof AttributesComponent, typeof SideNavigatorComponent, typeof HeaderBarComponent, typeof QuickAddComponent, typeof DateRangeQuickHeaderComponent, typeof FilterSelectComponent, typeof FilterSelectOptionTemplateDirective, typeof FilterSelectTriggerTemplateDirective], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i116.MatDialogModule, typeof i117.MatRadioModule, typeof ZacRoutingModule, typeof i119.MatDatepickerModule, typeof i120.MatNativeDateModule, typeof i121.MatFormFieldModule, typeof i122.MatInputModule, typeof i123.MatSelectModule, typeof i124.MatButtonModule, typeof i125.MatIconModule, typeof i126.OverlayModule, typeof i127.AgGridModule, typeof i128.QRCodeComponent, typeof i129.ClickOutsideModule, typeof i130.NgJsonEditorModule, typeof i131.MatTooltipModule, typeof i132.MatAutocompleteModule, typeof i133.LottieComponent, typeof DateTimePickerComponent], [typeof ExtendableComponent, typeof SideNavbarComponent, typeof StringInputComponent, typeof SelectorInputComponent, typeof PasswordInputComponent, typeof NumberInputComponent, typeof BooleanToggleInputComponent, typeof ObjectComponent, typeof TextListInputComponent, typeof ChipsInputComponent, typeof IdentityServicePathComponent, typeof NetworkVisualizerComponent, typeof CheckboxListInputComponent, typeof ProtocolAddressPortInputComponent, typeof ConfigurationsPageComponent, typeof ConfigurationFormComponent, typeof ConfigTypesPageComponent, typeof ConfigTypeFormComponent, typeof EdgeRouterFormComponent, typeof TransitRouterFormComponent, typeof IdentitiesPageComponent, typeof EdgeRoutersPageComponent, typeof TransitRoutersPageComponent, typeof ServicesPageComponent, typeof ZacRoutingModule, typeof SideModalComponent, typeof IdentityFormComponent, typeof LoadingIndicatorComponent, typeof GrowlerModule, typeof FormFieldContainerComponent, typeof FormFieldToggleComponent, typeof ServiceFormComponent, typeof ServicePoliciesPageComponent, typeof ServicePolicyFormComponent, typeof EdgeRouterPoliciesPageComponent, typeof TerminatorsPageComponent, typeof TerminatorFormComponent, typeof JwtSignersPageComponent, typeof JwtSignerFormComponent, typeof AuthPoliciesPageComponent, typeof AuthPolicyFormComponent, typeof LoginDialogComponent, typeof PostureChecksPageComponent, typeof PostureCheckFormComponent, typeof SessionsPageComponent, typeof SessionFormComponent, typeof APISessionsPageComponent, typeof APISessionFormComponent, typeof CallbackComponent, typeof FormHeaderComponent, typeof JsonViewComponent, typeof PreviewListComponent, typeof TagSelectorComponent, typeof ProgressMeterComponent, typeof ProgressWizardComponent, typeof ConfigEditorComponent, typeof SettingsComponent, typeof ProfileComponent, typeof GeolocateComponent, typeof AttributesComponent, typeof HeaderBarComponent, typeof SideNavigatorComponent, typeof FilterSelectComponent, typeof FilterSelectOptionTemplateDirective, typeof FilterSelectTriggerTemplateDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OpenZitiConsoleLibModule>;
}

declare class NoopLoginService extends LoginServiceClass {
    httpClient: HttpClient;
    settingsService: SettingsServiceClass;
    router: Router;
    growlerService: GrowlerService;
    constructor(httpClient: HttpClient, settingsService: SettingsServiceClass, router: Router, growlerService: GrowlerService);
    init(): void;
    clearSession(): void;
    login(prefix: string, url: string, username: string, password: string, isTest?: any): void;
    logout(): void;
    observeLogin(serviceUrl: string, username: string, password: string, isTest?: any): void;
    checkOriginForController(): Promise<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NoopLoginService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NoopLoginService>;
}

declare class NodeDataService extends ZitiDataService {
    logger: LoggerService;
    growler: GrowlerService;
    settingsService: SettingsService;
    httpClient: HttpClient;
    router: Router;
    dataServiceType: string;
    constructor(logger: LoggerService, growler: GrowlerService, settingsService: SettingsService, httpClient: HttpClient, router: Router);
    post(type: any, model: any, chained?: boolean): Promise<any>;
    put(type: any, model: any, id: any, chained?: boolean): Promise<any>;
    patch(type: any, model: any, id: any, chained?: boolean): Promise<any>;
    doGet(type: string, paging: any, filters?: FilterObj[], url?: any, useClient?: any): Promise<any>;
    doGetSubdata(entityType: string, id: any, dataType: string): Promise<any>;
    saveSubdata(entityType: string, id: any, dataType: string, data: any): Promise<any>;
    resetEnrollment(id: string, date: any): Promise<any>;
    deleteEnrollment(enrollmentId: string): Promise<any>;
    reissueEnrollment(id: string, date: string): Promise<any>;
    resetMFA(id: any): Promise<any>;
    resetPassword(oldPass: any, newPass: any, confirmPass: any): Promise<any>;
    deleteSubdata(entityType: string, id: any, dataType: string, data: any): Promise<any>;
    delete(type: string, id: string): Promise<any>;
    call(url: any, prefix?: string): Promise<any>;
    /**
     * NodeDataService doesn't support HA, so just fall back to regular call()
     */
    callHAControllers(url: string, prefix?: string): Promise<any>;
    schema(data: any): Promise<any>;
    private getUrlFilter;
    getAttributeFilter(val: any, columnId: any): string;
    handleError(results: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NodeDataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NodeDataService>;
}

declare class ZitiControllerDataService extends ZitiDataService {
    logger: LoggerService;
    growler: GrowlerService;
    httpClient: HttpClient;
    router: Router;
    constructor(logger: LoggerService, growler: GrowlerService, settingsService: SettingsService, httpClient: HttpClient, router: Router);
    post(type: any, model: any, chained?: boolean, contentType?: any): Promise<any>;
    put(type: any, model: any, id: any, chained?: boolean): Promise<any>;
    patch(type: any, model: any, id: any, chained?: boolean): Promise<any>;
    doGet(type: string, paging: any, filters?: FilterObj[], url?: any, useClient?: any): Promise<any>;
    doGetSubdata(entityType: string, id: any, dataType: string, paging?: any, contentType?: any, filters?: any[]): Promise<any>;
    saveSubdata(entityType: string, id: any, dataType: string, params: any): Promise<any>;
    deleteSubdata(entityType: string, id: any, dataType: string, params: any): Promise<any>;
    resetEnrollment(id: string, date: any): Promise<any>;
    deleteEnrollment(enrollmentId: string): Promise<any>;
    reissueEnrollment(id: string, date: any): Promise<any>;
    resetMFA(id: any): Promise<Object>;
    resetPassword(oldPass: any, newPass: any, confirmPass: any): Promise<Object>;
    delete(type: string, id: string): Promise<any>;
    call(callUrl: any, prefix?: any): Promise<any>;
    /**
     * Call HA controllers in parallel and merge responses
     * @param callUrl The API endpoint path
     * @param prefix The API prefix (e.g., '/fabric/v1')
     * @returns Promise with merged data and metadata about controller responses
     */
    callHAControllers(callUrl: string, prefix?: string): Promise<any>;
    /**
     * Merge responses from multiple HA controllers
     * @param responses Array of response objects from different controllers
     * @returns Merged response object
     */
    private mergeHAResponses;
    private getUrlFilter;
    schema(data: any): Promise<any>;
    dereferenceJSONSchema(data: any): Promise<any>;
    getAttributeFilter(val: any, columnId: any, semantic?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZitiControllerDataService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZitiControllerDataService>;
}

declare const ZITI_DOMAIN_CONTROLLER: InjectionToken<any>;
type ZitiSessionData = {
    zitiDomain: any;
    zitiSessionId: any;
    expiresAt: any;
};
interface ZitiDomainControllerService {
    zitiSettings: BehaviorSubject<ZitiSessionData>;
    handleUnauthorized(): any;
}

declare const DEACTIVATE_GUARD: InjectionToken<DeactivateGuardService>;
interface CanComponentDeactivate {
    canDeactivate: () => Observable<boolean> | Promise<boolean> | boolean;
}
declare class DeactivateGuardService implements CanDeactivate<CanComponentDeactivate> {
    canDeactivate(component: CanComponentDeactivate): boolean | Observable<boolean> | Promise<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DeactivateGuardService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DeactivateGuardService>;
}

declare class InsecureContextError extends Error {
    constructor();
}
declare function randomUrlSafeString(byteLen?: number): string;
declare function pkceChallengeS256(verifier: string): Promise<string>;
declare function decodeJwtPayload(token: string): any | null;
declare function jwtExpMs(token: string): number | undefined;
declare function jwtIatMs(token: string): number | undefined;

declare const OIDC_CLIENT_ID = "openziti";
declare const OIDC_CLIENT_ID_LEGACY = "native";
interface OidcTokenSet {
    accessToken: string;
    refreshToken?: string;
    idToken?: string;
    expiresAt: number;
    refreshExpiresAt?: number;
    clientId: string;
}
interface OidcAuthContext {
    controllerUrl: string;
    oidcBase: string;
    authRequestId: string;
    state: string;
    nonce: string;
    codeVerifier: string;
    redirectUri: string;
    clientId: string;
}
type OidcLoginStep = {
    status: 'code';
    code: string;
} | {
    status: 'totpRequired';
    authQueries: any[];
} | {
    status: 'error';
    error: any;
};
declare class OidcEnvironmentalError extends Error {
    causedBy?: any;
    constructor(message: string, causedBy?: any);
}
declare class OidcSessionUnrecoverableError extends Error {
    reason?: string;
    constructor(message: string, reason?: string);
}
/**
 * Drives the ziti controller's native OIDC provider (auth code + PKCE) programmatically,
 * the same way the ziti SDKs do, so the console keeps its own login UI.
 *
 * Uses fetch rather than HttpClient: the auth request id and authorization code must be
 * parsed from Response.url after redirect-following (the controller's CORS config does not
 * expose the auth-request-id/totp-required headers cross-origin), and these requests must
 * bypass the app's HTTP interceptors.
 */
declare class ZitiOidcService {
    private inflightRefresh;
    buildRedirectUri(): string;
    startAuthRequest(controllerUrl: string, options?: {
        redirectUri?: string;
        oidcPath?: string;
    }): Promise<OidcAuthContext>;
    private authorize;
    loginWithPassword(ctx: OidcAuthContext, username: string, password: string): Promise<OidcLoginStep>;
    loginWithExtJwt(ctx: OidcAuthContext, extToken: string): Promise<OidcLoginStep>;
    loginWithCert(ctx: OidcAuthContext): Promise<OidcLoginStep>;
    submitTotp(ctx: OidcAuthContext, code: string): Promise<OidcLoginStep>;
    private submitLogin;
    exchangeCode(ctx: OidcAuthContext, code: string): Promise<OidcTokenSet>;
    refreshTokens(controllerUrl: string, refreshToken: string, clientId?: string, oidcPath?: string): Promise<OidcTokenSet>;
    private doRefresh;
    revokeToken(controllerUrl: string, token: string, hint: 'refresh_token' | 'access_token', clientId?: string, oidcPath?: string): Promise<void>;
    private toTokenSet;
    private normalizeUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZitiOidcService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZitiOidcService>;
}

/**
 * Keeps OIDC sessions alive by refreshing the access token before it expires, and
 * self-monitors for sessions that can no longer be renewed (refresh token expired or
 * revoked), logging the user out and returning them to the login page.
 */
declare class SessionRefreshService {
    private settingsService;
    private oidcService;
    private growlerService;
    private injector;
    private refreshTimer;
    private monitorInterval;
    private retryDelayMs;
    private running;
    private readonly onWake;
    private readonly onStorage;
    constructor(settingsService: SettingsServiceClass, oidcService: ZitiOidcService, growlerService: GrowlerService, injector: Injector);
    start(): void;
    stop(): void;
    refreshNow(): Promise<boolean>;
    private persistTokens;
    private scheduleNextRefresh;
    private scheduleRetry;
    private checkSessionState;
    private hasOidcSession;
    private handleUnrecoverable;
    static ɵfac: i0.ɵɵFactoryDeclaration<SessionRefreshService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SessionRefreshService>;
}

declare const ZITI_URLS: InjectionToken<string>;
declare const ZITI_NAVIGATOR: InjectionToken<string>;
declare const DEFAULT_APP_CONFIG: InjectionToken<string>;

declare const ZAC_VERSION: {
    version: string;
};

export { APISessionFormComponent, APISessionsPageComponent, API_RESOURCE_TO_ENTITY_PERMISSION, ApiSessionsPageService, AttributesComponent, AuthPoliciesPageComponent, AuthPoliciesPageService, AuthPolicyFormComponent, AuthPolicyFormService, AuthService, BooleanToggleInputComponent, CallbackComponent, CardListComponent, CertificateAuthoritiesPageComponent, CertificateAuthoritiesPageService, CertificateAuthorityFormComponent, CertificateAuthorityFormService, CheckboxListInputComponent, ChipsInputComponent, ConfigEditorComponent, ConfigTypeFormComponent, ConfigTypesPageComponent, ConfigurationFormComponent, ConfigurationService, ConfigurationsPageComponent, CsvDownloadService, DEACTIVATE_GUARD, DEFAULT_APP_CONFIG, DataTableFilterService, DeactivateGuardService, EDGE_ROUTER_EXTENSION_SERVICE, EDGE_ROUTER_POLICY_EXTENSION_SERVICE, EdgeRouter, EdgeRouterFormComponent, EdgeRouterFormService, EdgeRouterPoliciesPageComponent, EdgeRouterPoliciesPageService, EdgeRouterPolicyFormComponent, EdgeRouterPolicyFormService, EdgeRoutersPageComponent, EdgeRoutersPageService, Entity, ExtendableComponent, ExtensionsNoopService, FilterSelectComponent, FilterSelectOptionTemplateDirective, FilterSelectTriggerTemplateDirective, FormFieldContainerComponent, FormFieldToggleComponent, FormHeaderComponent, GeolocateComponent, GrowlerComponent, GrowlerModel, GrowlerModule, GrowlerService, HAControllerService, HaStatusIndicatorComponent, HeaderBarComponent, IDENTITY_EXTENSION_SERVICE, IdentitiesPageComponent, IdentitiesPageService, Identity$1 as Identity, IdentityFormComponent, IdentityFormService, IdentityServicePathComponent, InsecureContextError, JsonViewComponent, JwtSignerFormComponent, JwtSignerFormService, JwtSignersPageComponent, JwtSignersPageService, KEY_CODES, ListPageComponent, ListPageServiceClass, LoadingIndicatorComponent, LoggerService, LoginDialogComponent, LoginServiceClass, ManagementPermissionsService, NetworkVisualizerComponent, NodeDataService, NoopLoginService, NoopTabInterceptorService, NumberInputComponent, OIDC_CLIENT_ID, OIDC_CLIENT_ID_LEGACY, ObjectComponent, OidcEnvironmentalError, OidcSessionUnrecoverableError, OpenZitiConsoleLibModule, PasswordInputComponent, PostureCheckFormComponent, PostureChecksPageComponent, PostureChecksPageService, PreviewListComponent, ProfileComponent, ProgressMeterComponent, ProgressMeterStep, ProgressWizardComponent, ProgressWizardStep, ProjectableForm, ProtocolAddressPortInputComponent, QuickAddComponent, ResetEnrollmentService, SAVE_DENIED_BY_PERMISSION_TOOLTIP, SERVICE_EDGE_ROUTER_POLICY_EXTENSION_SERVICE, SERVICE_EXTENSION_SERVICE, SERVICE_POLICY_EXTENSION_SERVICE, SETTINGS_SERVICE, SHAREDZ_EXTENSION, SelectorInputComponent, ServiceEdgeRouterPoliciesPageComponent, ServiceEdgeRouterPoliciesPageService, ServiceEdgeRouterPolicyFormComponent, ServiceEdgeRouterPolicyFormService, ServiceFormComponent, ServiceFormService, ServicePoliciesPageComponent, ServicePoliciesPageService, ServicePolicyFormComponent, ServicePolicyFormService, ServicesPageComponent, ServicesPageService, Session, SessionFormComponent, SessionRefreshService, SessionsPageComponent, SessionsPageService, SettingsComponent, SettingsService, SettingsServiceClass, SideModalComponent, SideNavbarComponent, SideNavigatorComponent, SimpleServiceComponent, StringInputComponent, TabNameService, TagSelectorComponent, TerminatorFormComponent, TerminatorFormService, TerminatorsPageComponent, TerminatorsPageService, TextListInputComponent, TransitRouterFormComponent, TransitRouterFormService, TransitRoutersPageComponent, TransitRoutersPageService, ValidationService, VerifyCertificateComponent, VisualizerServiceClass, ZAC_LOGIN_SERVICE, ZAC_VERSION, ZITI_DATA_SERVICE, ZITI_DOMAIN_CONTROLLER, ZITI_NAVIGATOR, ZITI_TAB_OVERRIDES, ZITI_URLS, ZacRoutingModule, ZitiControllerDataService, ZitiDataService, ZitiOidcService, decodeJwtPayload, jwtExpMs, jwtIatMs, pkceChallengeS256, playerFactory, randomUrlSafeString };
export type { CanComponentDeactivate, ExtensionEvent, ExtensionEventType, ExtensionService, FilterObj, HAClusterStatus, HAController, OidcAuthContext, OidcLoginStep, OidcTokenSet, TabInterceptorService, ZitiDomainControllerService, ZitiSessionData };
//# sourceMappingURL=index.d.ts.map