import * as _angular_animations from '@angular/animations';
import * as i0 from '@angular/core';
import { ViewContainerRef, ApplicationRef, Injector, ComponentRef, Type, PipeTransform, ChangeDetectorRef, EventEmitter, ElementRef, OnInit, OnDestroy, NgZone, AfterContentChecked, AfterViewInit, Renderer2, TemplateRef, OnChanges, QueryList, AfterContentInit, SimpleChanges, RendererFactory2, EnvironmentInjector, Binding } from '@angular/core';
import * as i2 from '@angular/common';
import moment, { Moment, MomentBuiltinFormat } from 'moment-timezone';
import * as i3 from '@angular/forms';
import { Validator, AbstractControl, NgModel, ControlValueAccessor, UntypedFormControl, ValidationErrors } from '@angular/forms';
import * as i4 from 'ng2-file-upload';
import { FileUploader, FileUploaderOptions, FileItem } from 'ng2-file-upload';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Subject, Observable, Subscription } from 'rxjs';
import { BooleanInput } from '@angular/cdk/coercion';
import * as i4$1 from 'ngx-moment';
import { DateFormatPipe } from 'ngx-moment';
import { SafeUrl } from '@angular/platform-browser';
import { HttpClient } from '@angular/common/http';
import * as CodeMirror from 'codemirror';
import * as i7 from '@angular/cdk/clipboard';
import { Clipboard } from '@angular/cdk/clipboard';
import * as i5 from '@angular/cdk/layout';
import { BreakpointObserver } from '@angular/cdk/layout';
import * as i5$1 from 'ng-in-viewport';
import { InViewportDirective, InViewportService, InViewportMetadata } from 'ng-in-viewport';
import * as i5$2 from '@angular/cdk/scrolling';
import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
import Ajv from 'ajv';
import { JSONSchema7, JSONSchema7TypeName, JSONSchema7Type } from 'json-schema';
import * as i15 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';

declare function bounceAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare function fadeInAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare function fadeOutAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare function slideBottomAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare function slideDownFadeOutAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare function slideLeftAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare function slideRightAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare function slideTopAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare function slideUpFadeOutAnimation(ms?: number): _angular_animations.AnimationTransitionMetadata[];

declare class IconRegistryService {
    private _defaultFontSetClass;
    private _iconMap;
    setDefaultFontSetClass(iconSet: string): string;
    get(keys: string | string[], set?: string): string[];
    lookup(keys: string | string[], set?: string): string[];
    add(key: string, icon: string | string[]): void;
    private _expandKeys;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconRegistryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IconRegistryService>;
}

/**
 * Injection service is a helper to append components
 * dynamically to a known location in the DOM, most
 * notably for dialogs/tooltips appending to body.
 *
 * @export
 */
declare class InjectionService {
    private applicationRef;
    private injector;
    static globalRootViewContainer: ViewContainerRef;
    private _container;
    /**
     * Sets a default global root view container. This is useful for
     * things like ngUpgrade that doesn't have a ApplicationRef root.
     *
     * @param container
     */
    static setGlobalRootViewContainer(container?: ViewContainerRef): void;
    constructor(applicationRef: ApplicationRef, injector: Injector);
    /**
     * Gets the root view container to inject the component to.
     *
     * @memberOf InjectionService
     */
    getRootViewContainer(): ViewContainerRef | ComponentRef<any>;
    /**
     * Overrides the default root view container. This is useful for
     * things like ngUpgrade that doesn't have a ApplicationRef root.
     *
     * @param container
     *
     * @memberOf InjectionService
     */
    setRootViewContainer(container: ViewContainerRef): void;
    /**
     * Gets the html element for a component ref.
     *
     * @param componentRef
     *
     * @memberOf InjectionService
     */
    getComponentRootNode(component: ViewContainerRef | ComponentRef<any>): HTMLElement;
    /**
     * Gets the root component container html element.
     *
     * @memberOf InjectionService
     */
    getRootViewContainerNode(component: ViewContainerRef | ComponentRef<any>): HTMLElement;
    /**
     * Projects the bindings onto the component
     *
     * @param component
     * @param options
     *
     * @memberOf InjectionService
     */
    projectComponentBindings(component: ComponentRef<any>, bindings?: Record<string, any>): ComponentRef<any>;
    /**
     * Appends a component to an adjacent location
     *
     * @param componentClass
     * @param [options={}]
     * @param [location]
     *
     * @memberOf InjectionService
     */
    appendComponent<T>(componentClass: Type<T>, bindings?: any, location?: ComponentRef<any> | ViewContainerRef): ComponentRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<InjectionService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<InjectionService>;
}

interface PartialBindings {
    inputs?: {
        [key: string]: any;
    };
    outputs?: {
        [key: string]: any;
    };
}

declare abstract class InjectionRegistryService<T = any> {
    protected readonly injectionService: InjectionService;
    protected defaults: PartialBindings;
    protected components: Map<any, ComponentRef<T>[]>;
    protected abstract type: Type<T>;
    constructor(injectionService: InjectionService);
    getByType(type?: Type<T>): ComponentRef<T>[];
    create(bindings: PartialBindings): ComponentRef<T>;
    createByType(type: Type<T>, bindings: PartialBindings): ComponentRef<T>;
    destroy(instance: ComponentRef<T>): void;
    destroyAll(): void;
    destroyByType(type: Type<T>): void;
    protected injectComponent(type: Type<T>, bindings: PartialBindings, location?: ComponentRef<any> | ViewContainerRef): ComponentRef<T>;
    protected assignDefaults(bindings: Record<string, any>): PartialBindings;
    protected register(type: Type<T>, component: ComponentRef<T>): void;
}

declare class TimeZonePipe implements PipeTransform {
    transform(value: Date | moment.Moment | string | number, timezone?: string): moment.Moment | string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeZonePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TimeZonePipe, "amTimeZone", false>;
}
declare class TimeZoneFormatPipe implements PipeTransform {
    transform(value: Date | moment.Moment | string | number, timezone?: string, format?: string): moment.Moment | string;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeZoneFormatPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TimeZoneFormatPipe, "amTimeZoneFormat", false>;
}

declare class TimeZoneModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeZoneModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TimeZoneModule, [typeof TimeZonePipe, typeof TimeZoneFormatPipe], [typeof i2.CommonModule], [typeof TimeZonePipe, typeof TimeZoneFormatPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TimeZoneModule>;
}

declare class DecamelizePipe implements PipeTransform {
    transform(input: unknown): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DecamelizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<DecamelizePipe, "decamelize", false>;
}

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

/**
 * Filter Pipe
 * A pipe like the old-school ng1 pipe. Use this with
 * moderation since it has performance issues.
 *
 * References:
 *  - https://github.com/VadimDez/ng2-filter-pipe
 *  - https://angular.io/docs/ts/latest/guide/pipes.html
 *
 * Example:
 *
 *    <input type="text" [(ngModel)]="stringFilter">
 *    <ul>
 *      <li *ngFor="let item of array | filterBy: stringFilter">
 *        {{ item }}
 *      </li>
 *    </ul>
 *
 */
declare class FilterPipe implements PipeTransform {
    transform(array: any[], filter: unknown): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<FilterPipe, "filterBy", false>;
}

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

declare class JSONTreePipe implements PipeTransform {
    transform(input: unknown): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<JSONTreePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<JSONTreePipe, "jsonTree", false>;
}

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

declare class CamelToSnakePipe implements PipeTransform {
    transform(input?: unknown): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CamelToSnakePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CamelToSnakePipe, "cameltosnake", false>;
}

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

declare class MemoizePipe implements PipeTransform {
    context: any;
    cdRef: ChangeDetectorRef;
    constructor();
    transform(fn: any, ...args: any[]): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<MemoizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MemoizePipe, "memoize", false>;
}

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

declare class PipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PipesModule, never, [typeof i2.CommonModule, typeof TimeZoneModule, typeof DecamelizeModule, typeof FilterModule, typeof JSONTreeModule, typeof CamelToSnakeModule, typeof MemoizeModule], [typeof TimeZoneModule, typeof DecamelizeModule, typeof FilterModule, typeof JSONTreeModule, typeof CamelToSnakeModule, typeof MemoizeModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PipesModule>;
}

declare class DblClickCopyDirective {
    private readonly element;
    onCopy: EventEmitter<Range>;
    constructor(element: ElementRef<HTMLElement>);
    onDblClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DblClickCopyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DblClickCopyDirective, "[dbl-click-copy]", never, {}, { "onCopy": "onCopy"; }, never, never, false, never>;
}

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

declare class LongPressDirective {
    get duration(): number;
    set duration(duration: number);
    get disabled(): boolean;
    set disabled(disabled: boolean);
    longPressStart: EventEmitter<boolean>;
    longPressFinish: EventEmitter<boolean>;
    longPressCancel: EventEmitter<boolean>;
    private _duration;
    private _disabled;
    private _pressed;
    private _pressTimeout;
    onPress(event: MouseEvent): void;
    onRelease(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LongPressDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LongPressDirective, "[long-press]", never, { "duration": { "alias": "duration"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "longPressStart": "longPressStart"; "longPressFinish": "longPressFinish"; "longPressCancel": "longPressCancel"; }, never, never, false, never>;
}

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

declare class ResizeObserverDirective implements OnInit, OnDestroy {
    private readonly _el;
    resize: EventEmitter<Partial<DOMRectReadOnly>>;
    private _observer;
    private _timer;
    constructor(_el: ElementRef<HTMLElement>);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onResize(e: Partial<DOMRectReadOnly>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeObserverDirective, "[resizeObserver]", ["resizeObserver"], {}, { "resize": "resizeObserver"; }, never, never, false, never>;
}

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

declare class PatternValidatorDirective implements Validator {
    pattern: string;
    validate(control: AbstractControl): {
        [key: string]: any;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<PatternValidatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<PatternValidatorDirective, "[pattern]", never, { "pattern": { "alias": "pattern"; "required": false; }; }, {}, never, never, false, never>;
}

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

/**
 * Visibility Observer Directive
 *
 * Usage:
 *
 * 		<div
 * 			visibilityObserver
 * 			(visible)="onVisible($event)">
 * 		</div>
 *
 */
declare class VisibilityDirective implements OnInit, OnDestroy {
    private readonly element;
    private readonly zone;
    isVisible: boolean;
    visible: EventEmitter<boolean>;
    timeout: any;
    constructor(element: ElementRef<HTMLElement>, zone: NgZone);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onVisibilityChange(): void;
    runCheck(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisibilityDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VisibilityDirective, "[visibilityObserver]", never, {}, { "visible": "visible"; }, never, never, false, never>;
}

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

declare class AutoSizeInputDirective implements AfterContentChecked, AfterViewInit {
    private element;
    private ngModel;
    private renderer;
    extraWidth: number;
    includeBorders: boolean;
    includePadding: boolean;
    includePlaceholder: boolean;
    maxWidth: number;
    minWidth: number;
    setParentWidth: boolean;
    constructor(element: ElementRef, ngModel: NgModel, renderer: Renderer2);
    get borderWidth(): number;
    get paddingWidth(): number;
    ngAfterContentChecked(): void;
    ngAfterViewInit(): void;
    onInput(): void;
    setWidth(width: number): void;
    setWidthUsingText(text: string): void;
    textWidth(value: string): number;
    updateWidth(): void;
    private _getProperty;
    private _getPropertyWidth;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoSizeInputDirective, [null, { optional: true; }, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoSizeInputDirective, "[autoSizeInput]", never, { "extraWidth": { "alias": "extraWidth"; "required": false; }; "includeBorders": { "alias": "includeBorders"; "required": false; }; "includePadding": { "alias": "includePadding"; "required": false; }; "includePlaceholder": { "alias": "includePlaceholder"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "setParentWidth": { "alias": "setParentWidth"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare enum FileButtonStyleType {
    standard,
    progress
}

declare class FileButtonComponent implements OnInit {
    readonly _ngZone: NgZone;
    id: string;
    name: string;
    styleType: FileButtonStyleType;
    uploader: FileUploader;
    options: FileUploaderOptions;
    disabled: boolean;
    multiple: boolean;
    afterAddingFile: EventEmitter<{
        fileItem: FileItem;
    }>;
    beforeUploadItem: EventEmitter<{
        fileItem: FileItem;
    }>;
    successItem: EventEmitter<{
        item: any;
        response: string;
        status: number;
        headers: any;
    }>;
    errorItem: EventEmitter<{
        response: string;
        status: number;
        headers: any;
    }>;
    progressAll: EventEmitter<{
        progress: number;
    }>;
    readonly dropzoneTemplate: TemplateRef<any>;
    readonly fileInput?: ElementRef<HTMLInputElement>;
    get isDisabled(): boolean;
    get cssClasses(): any;
    readonly FileButtonStyleType: typeof FileButtonStyleType;
    progress: number;
    fileName: string;
    fileOverDropzone: boolean;
    private _isItemSuccessful;
    constructor(_ngZone: NgZone);
    ngOnInit(): void;
    onAfterAddingFile(fileItem: FileItem): void;
    onBeforeUploadItem(fileItem: FileItem): void;
    onErrorItem(response: string, status: number, headers: any): void;
    onProgressAll(progress: number): void;
    onSuccessItem(item: any, response: string, status: number, headers: any): void;
    fileOverBase(event: boolean): void;
    clearInput(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileButtonComponent, "ngx-file-button", ["ngxFileButton"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "uploader": { "alias": "uploader"; "required": false; }; "options": { "alias": "options"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; }, { "afterAddingFile": "afterAddingFile"; "beforeUploadItem": "beforeUploadItem"; "successItem": "successItem"; "errorItem": "errorItem"; "progressAll": "progressAll"; }, ["dropzoneTemplate"], ["*"], false, never>;
}

declare enum ButtonState {
    InProgress = "in-progress",
    Active = "active",
    Success = "success",
    Fail = "fail"
}

declare class ButtonComponent implements OnInit, OnChanges {
    promise?: Promise<any>;
    disabled: boolean;
    type: string;
    get state(): ButtonState;
    set state(v: ButtonState);
    get timeout(): number;
    set timeout(v: number);
    readonly inProgress$: BehaviorSubject<boolean>;
    readonly active$: BehaviorSubject<boolean>;
    readonly success$: BehaviorSubject<boolean>;
    readonly fail$: BehaviorSubject<boolean>;
    private _state;
    private _timer;
    private _timeout;
    ngOnInit(): void;
    ngOnChanges(): void;
    updatePromise(): Promise<void>;
    updateState(): void;
    onClick(event: Event): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "ngx-button", ["ngxButton"], { "promise": { "alias": "promise"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "type": { "alias": "type"; "required": false; }; "state": { "alias": "state"; "required": false; }; "timeout": { "alias": "timeout"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class ButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, [typeof FileButtonComponent, typeof ButtonComponent], [typeof i2.CommonModule, typeof i4.FileUploadModule], [typeof FileButtonComponent, typeof i4.FileUploadModule, typeof ButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonModule>;
}

declare enum ButtonGroupOrientation {
    Horizontal = "horizontal",
    Vertical = "vertical"
}
declare enum ButtonGroupVariant {
    Contained = "contained",
    Text = "text"
}
declare enum BottonGroupStyle {
    Default = "default",
    Primary = "primary"
}
declare class ButtonGroupComponent {
    orientation: ButtonGroupOrientation;
    variant: ButtonGroupVariant;
    buttonGroupStyle: BottonGroupStyle;
    get Horizontal(): boolean;
    get vertical(): boolean;
    get Contained(): boolean;
    get text(): boolean;
    get default(): boolean;
    get primary(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonGroupComponent, "ngx-button-group", ["ngxButtonGroup"], { "orientation": { "alias": "orientation"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "buttonGroupStyle": { "alias": "buttonGroupStyle"; "required": false; }; }, {}, never, ["*"], false, never>;
}

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

declare class ButtonToggleComponent implements ControlValueAccessor {
    readonly element: ElementRef;
    private readonly cdr;
    readonly UNIQUE_ID: string;
    private _checked;
    private _value;
    private _disabled;
    id: string;
    name: string;
    get checked(): boolean;
    set checked(value: boolean);
    get value(): any;
    set value(newValue: any);
    get disabled(): boolean;
    set disabled(value: BooleanInput);
    readonly valueChange: EventEmitter<any>;
    onChangeCallback: (value: any) => void;
    onTouchedCallback: (value: any) => void;
    writeValue(incomingValue: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    constructor(element: ElementRef, // this is accessed in toggle-group to calculate animation
    cdr: ChangeDetectorRef);
    handleClick(incomingEvent: Event): void;
    markForCheck(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonToggleComponent, "ngx-button-toggle", never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["*"], false, never>;
}

declare class ButtonToggleGroupComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {
    private readonly cdr;
    readonly UNIQUE_ID: string;
    private _value;
    private _disabled;
    id: string;
    label: any;
    get value(): any;
    set value(newValue: any);
    get disabled(): boolean;
    set disabled(value: BooleanInput);
    readonly valueChange: EventEmitter<any>;
    buttonToggles: QueryList<ButtonToggleComponent>;
    onChangeCallback: (value: any) => void;
    onTouchedCallback: (value: any) => void;
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    animationHolderLeft: number | undefined;
    animationHolderWidth: number;
    get itemCount(): number;
    readonly destroy$: Subject<void>;
    constructor(cdr: ChangeDetectorRef);
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    listenChildren(): void;
    notifyChange(selectedToggleValue: any): void;
    selectButtonToggle(incomingValue: any): void;
    clearButtonToggles(): void;
    checkChildren(disabled: boolean): void;
    private calcAnimationDimensions;
    private getToggleIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonToggleGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonToggleGroupComponent, "ngx-button-toggle-group", never, { "id": { "alias": "id"; "required": false; }; "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "valueChange": "valueChange"; }, ["buttonToggles"], ["*"], false, never>;
}

declare class ButtonToggleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonToggleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonToggleModule, [typeof ButtonToggleGroupComponent, typeof ButtonToggleComponent], [typeof i2.CommonModule], [typeof ButtonToggleGroupComponent, typeof ButtonToggleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonToggleModule>;
}

interface CalendarDay {
    num: number;
    dayOfWeek: number;
    date: Moment;
    today?: boolean;
    nextMonth?: boolean;
    prevMonth?: boolean;
    classes?: string[] | Set<string> | {
        [klass: string]: any;
    };
}

type CalendarMonth = CalendarDay[][];

declare enum CalendarView {
    Year = "year",
    Month = "month",
    Date = "date"
}

declare enum CalendarSelect {
    Single = "single",
    Range = "range"
}

interface CalendarDateRange {
    startDate: Date | undefined;
    endDate: Date | undefined;
}
declare class CalendarComponent implements OnInit, AfterViewInit, ControlValueAccessor {
    private readonly cdr;
    private readonly elm;
    minDate: Date | string;
    disabled: boolean;
    maxDate: Date | string;
    daysOfWeek: string[];
    timezone: string;
    inputFormats: Array<string | MomentBuiltinFormat>;
    selectType: string;
    dateLabelFormat: string;
    range: CalendarDateRange;
    showStartTimeInputs: boolean;
    showEndTimeInputs: boolean;
    get minView(): CalendarView;
    set minView(val: CalendarView);
    get defaultView(): CalendarView;
    set defaultView(val: CalendarView);
    change: EventEmitter<Date>;
    onRangeSelect: EventEmitter<CalendarDateRange>;
    dayKeyEnter: EventEmitter<Date>;
    tabindex: number;
    get value(): Date;
    set value(val: Date);
    get current(): Moment;
    focusDate: Moment;
    weeks: CalendarMonth;
    currentView: CalendarView;
    monthsList: string[];
    startYear: number;
    startHour: string;
    endHour: string;
    startMinute: string;
    endMinute: string;
    startAmPmVal: string;
    endAmPmVal: string;
    readonly CalendarView: typeof CalendarView;
    readonly CalendarSelect: typeof CalendarSelect;
    private _value;
    private _current;
    private _minView;
    private _defaultView;
    constructor(cdr: ChangeDetectorRef, elm: ElementRef);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    changeViews(): void;
    validateView(): void;
    /**
     * Initializes the values for initial time
     */
    initializeTime(): void;
    /**
     * Checks if `date` matches selected value
     */
    isDayActive(date: Moment): boolean;
    /**
     * Checks if `date` matches the extreme ends of range
     */
    isDayRangeEnd(date: Moment): boolean;
    isDayRangeStart(date: Moment): boolean;
    isRangeStartActive(date: Moment): boolean;
    /**
     * Checks if `date` matches the extreme ends of range
     */
    isDayInRange(date: Moment): boolean;
    /**
     * Checks if `date` matches selected value
     */
    isDayFocus(date: Moment): boolean;
    /**
     * Checks if `month` matches selected value, in the viewed year
     */
    isMonthActive(month: string): boolean;
    /**
     * Checks if `month` and year matches current
     */
    isCurrentMonth(month: string): boolean;
    /**
     * Checks if `month` and year matches current focus
     */
    isFocusMonth(month: string): boolean;
    /**
     * Checks if `year` matches selected year
     */
    isYearActive(year: number): boolean;
    /**
     * Checks if year matches current year
     */
    isCurrentYear(year: number): boolean;
    /**
     * Checks if year matches current focus
     */
    isFocusYear(year: number): boolean;
    isDisabled(value: any, type: string): boolean;
    onDayClick(day: CalendarDay): void;
    onDaySelectRange(day: CalendarDay): void;
    onDayFocus(day: CalendarDay): void;
    onMonthClick(month: string): void;
    onYearClick(year: number): void;
    hourChanged(newVal: string, type: string): void;
    minuteChanged(newVal: string, type: string): void;
    onAmPmChange(newVal: any, type: any): void;
    prevMonth(): void;
    nextMonth(): void;
    prevYear(): void;
    nextYear(): void;
    moveFocus(amount: number, duration: moment.unitOfTime.DurationConstructor): void;
    setFocus(focusDate: Moment): void;
    prevTwoDecades(): void;
    nextTwoDecades(): void;
    writeValue(val: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onTouchedCallback: () => void;
    focus(): void;
    onDayDown(event: KeyboardEvent): void;
    onMonthDown(event: KeyboardEvent): void;
    onYearDown(event: KeyboardEvent): void;
    formatDate(date: Date): string;
    compareCalendarDays(date1: Date, date2: Date): boolean;
    private onChangeCallback;
    private parseDate;
    private createMoment;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarComponent, "ngx-calendar", ["ngxCalendar"], { "minDate": { "alias": "minDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "daysOfWeek": { "alias": "daysOfWeek"; "required": false; }; "timezone": { "alias": "timezone"; "required": false; }; "inputFormats": { "alias": "inputFormats"; "required": false; }; "selectType": { "alias": "selectType"; "required": false; }; "dateLabelFormat": { "alias": "dateLabelFormat"; "required": false; }; "range": { "alias": "range"; "required": false; }; "showStartTimeInputs": { "alias": "showStartTimeInputs"; "required": false; }; "showEndTimeInputs": { "alias": "showEndTimeInputs"; "required": false; }; "minView": { "alias": "minView"; "required": false; }; "defaultView": { "alias": "defaultView"; "required": false; }; }, { "change": "change"; "onRangeSelect": "onRangeSelect"; "dayKeyEnter": "dayKeyEnter"; }, never, never, false, never>;
}

declare enum Appearance {
    Legacy = "legacy",
    Fill = "fill"
}

declare enum InputTypes {
    text = "text",
    number = "number",
    password = "password",
    textarea = "textarea"
}

declare enum Size {
    Small = "sm",
    Medium = "md",
    Large = "lg"
}

declare class InputComponent implements AfterViewInit, OnDestroy, ControlValueAccessor, Validator {
    private readonly cdr;
    id: string;
    name: string;
    label: string;
    hint: string;
    placeholder: string;
    tabindex: number;
    min: number;
    max: number;
    minlength: number;
    maxlength: number;
    size: Size;
    appearance: Appearance;
    withMargin: boolean;
    withHint: boolean;
    textareaRows: number;
    get disabled(): boolean;
    set disabled(disabled: boolean);
    get readonly(): boolean;
    set readonly(readonly: boolean);
    get minWidth(): number;
    set minWidth(minWidth: number);
    requiredIndicator: string | boolean;
    get required(): boolean;
    set required(required: boolean);
    passwordToggleEnabled: boolean;
    get passwordTextVisible(): boolean;
    set passwordTextVisible(p: boolean);
    get autoSelect(): boolean;
    set autoSelect(autoSelect: boolean);
    get autofocus(): boolean;
    set autofocus(autofocus: boolean);
    get autocomplete(): boolean | string;
    set autocomplete(autocomplete: boolean | string);
    get autocorrect(): boolean;
    set autocorrect(autocorrect: boolean);
    get spellcheck(): boolean;
    set spellcheck(spellcheck: boolean);
    get type(): InputTypes;
    set type(type: InputTypes);
    get autosize(): boolean;
    set autosize(v: boolean);
    get unlockable(): boolean;
    set unlockable(v: boolean);
    unlockableTooltip: string;
    change: EventEmitter<string | number>;
    blur: EventEmitter<Event>;
    focus: EventEmitter<FocusEvent>;
    keyup: EventEmitter<KeyboardEvent>;
    click: EventEmitter<Event>;
    select: EventEmitter<FocusEvent>;
    lockChange: EventEmitter<boolean>;
    readonly inputControl: ElementRef<HTMLInputElement>;
    readonly inputModel: NgModel;
    readonly textareaControl: ElementRef<HTMLTextAreaElement>;
    get value(): string | number;
    set value(val: string | number);
    get valueAsString(): string;
    get valueAsNumber(): number;
    get focusedOrDirty(): any;
    get isBadInput(): boolean;
    get isTouched(): boolean;
    get hasPlaceholder(): boolean;
    get labelState(): boolean;
    get underlineState(): string;
    get element(): ElementRef<HTMLInputElement> | ElementRef<HTMLTextAreaElement>;
    focused: boolean;
    readonly type$: BehaviorSubject<InputTypes>;
    readonly inputTypes: typeof InputTypes;
    private _value;
    private _type;
    private _passwordTextVisible;
    private _disabled;
    private _readonly;
    private _required;
    private _autoSelect;
    private _autofocus;
    private _autocomplete;
    private _autocorrect;
    private _spellcheck;
    private _autosize;
    private _spinnerInterval;
    private _spinnerTimeout;
    private _minWidth;
    private _unlockable;
    constructor(cdr: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onChange(event: Event): void;
    onKeyUp(event: KeyboardEvent): void;
    onFocus(event: FocusEvent): void;
    onBlur(event: Event): void;
    validate(c: UntypedFormControl): ValidationErrors | null;
    writeValue(val: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    togglePassword(): void;
    setDisabledState(isDisabled: boolean): void;
    unlock(): void;
    incrementValue(event: MouseEvent): void;
    decrementValue(event: MouseEvent): void;
    clearSpinnerInterval(): void;
    private onTouchedCallback;
    private onChangeCallback;
    private updateInputType;
    private increment;
    private decrement;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "ngx-input", ["ngxInput"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "minlength": { "alias": "minlength"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "size": { "alias": "size"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "withMargin": { "alias": "withMargin"; "required": false; }; "withHint": { "alias": "withHint"; "required": false; }; "textareaRows": { "alias": "textareaRows"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "requiredIndicator": { "alias": "requiredIndicator"; "required": false; }; "required": { "alias": "required"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; "passwordTextVisible": { "alias": "passwordTextVisible"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "autocorrect": { "alias": "autocorrect"; "required": false; }; "spellcheck": { "alias": "spellcheck"; "required": false; }; "type": { "alias": "type"; "required": false; }; "autosize": { "alias": "autosize"; "required": false; }; "unlockable": { "alias": "unlockable"; "required": false; }; "unlockableTooltip": { "alias": "unlockableTooltip"; "required": false; }; }, { "change": "change"; "blur": "blur"; "focus": "focus"; "keyup": "keyup"; "click": "click"; "select": "select"; "lockChange": "lockChange"; }, never, ["ngx-input-prefix", "ngx-input-suffix", "ngx-input-hint"], false, never>;
}

declare class InputHintDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputHintDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InputHintDirective, "ngx-input-hint", ["ngxInputHint"], {}, {}, never, never, false, never>;
}

declare class AutosizeDirective implements AfterContentInit {
    readonly element: ElementRef<HTMLInputElement | HTMLTextAreaElement>;
    private readonly ngModel;
    get enabled(): boolean;
    set enabled(v: boolean);
    private _enabled;
    get nodeName(): "TEXTAREA" | "INPUT";
    constructor(element: ElementRef<HTMLInputElement | HTMLTextAreaElement>, ngModel: NgModel);
    ngAfterContentInit(): void;
    onInput(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutosizeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutosizeDirective, "textarea[autosize], input[autosize]", ["ngxAutosize"], { "enabled": { "alias": "autosize"; "required": false; }; }, {}, never, never, false, never>;
}

declare class InputPrefixComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputPrefixComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputPrefixComponent, "ngx-input-prefix", ["ngxInputPrefix"], {}, {}, never, ["*"], false, never>;
}

declare class InputSuffixComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputSuffixComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputSuffixComponent, "ngx-input-suffix", ["ngxInputSuffix"], {}, {}, never, ["*"], false, never>;
}

declare enum AlignmentTypes {
    top = "top",
    bottom = "bottom",
    left = "left",
    right = "right",
    center = "center"
}

declare enum PlacementTypes {
    top = "top",
    bottom = "bottom",
    left = "left",
    right = "right"
}

declare enum StyleTypes {
    popover = "popover",
    tooltip = "tooltip"
}

declare class TooltipContentComponent implements AfterViewInit {
    readonly element: ElementRef<HTMLElement>;
    private readonly renderer;
    readonly caretElm: ElementRef<HTMLSpanElement>;
    host: ElementRef<HTMLElement>;
    type: StyleTypes;
    placement: PlacementTypes;
    alignment: AlignmentTypes;
    cssClass: string;
    title: string;
    template: TemplateRef<any>;
    context: any;
    get showCaret(): boolean;
    set showCaret(val: boolean);
    get spacing(): number;
    set spacing(val: number);
    private _spacing;
    private _showCaret;
    get hostElement(): HTMLElement;
    get cssClasses(): string;
    constructor(element: ElementRef<HTMLElement>, renderer: Renderer2);
    ngAfterViewInit(): void;
    onWindowResize(): void;
    position(): void;
    private positionContent;
    private positionCaret;
    private checkFlip;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipContentComponent, "ngx-tooltip-content", ["ngxTooltipContent"], { "host": { "alias": "host"; "required": false; }; "type": { "alias": "type"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "alignment": { "alias": "alignment"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "title": { "alias": "title"; "required": false; }; "template": { "alias": "template"; "required": false; }; "context": { "alias": "context"; "required": false; }; "showCaret": { "alias": "showCaret"; "required": false; }; "spacing": { "alias": "spacing"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum ShowTypes {
    all = "all",
    focus = "focus",
    click = "click",
    mouseover = "mouseover"
}

declare class TooltipService extends InjectionRegistryService<TooltipContentComponent> {
    type: Type<TooltipContentComponent>;
    constructor(injectionService: InjectionService);
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipService>;
}

declare class TooltipDirective implements OnDestroy {
    private readonly ngZone;
    private readonly tooltipService;
    private readonly viewContainerRef;
    private readonly renderer;
    private readonly element;
    tooltipCssClass: string;
    tooltipTitle: string;
    tooltipPlacement: PlacementTypes;
    tooltipAlignment: AlignmentTypes;
    tooltipType: StyleTypes;
    tooltipTemplate: TemplateRef<any>;
    tooltipShowEvent: ShowTypes;
    tooltipContext: any;
    get tooltipSpacing(): number;
    set tooltipSpacing(val: number);
    get tooltipDisabled(): boolean;
    set tooltipDisabled(val: boolean);
    get tooltipShowCaret(): boolean;
    set tooltipShowCaret(val: boolean);
    get tooltipCloseOnClickOutside(): boolean;
    set tooltipCloseOnClickOutside(val: boolean);
    get tooltipCloseOnMouseLeave(): boolean;
    set tooltipCloseOnMouseLeave(val: boolean);
    get tooltipHideTimeout(): number;
    set tooltipHideTimeout(val: number);
    get tooltipShowTimeout(): number;
    set tooltipShowTimeout(val: number);
    show: EventEmitter<boolean>;
    hide: EventEmitter<boolean>;
    private _tooltipSpacing;
    private _tooltipDisabled;
    private _tooltipShowCaret;
    private _tooltipCloseOnClickOutside;
    private _tooltipCloseOnMouseLeave;
    private _tooltipHideTimeout;
    private _tooltipShowTimeout;
    private _tooltipIsOpenFromClick;
    private get listensForFocus();
    private get listensForHover();
    private get listensForClick();
    private component;
    private timeout;
    private mouseLeaveContentEvent;
    private mouseEnterContentEvent;
    private documentClickEvent;
    get tooltipIsOpenFromClick(): boolean;
    constructor(ngZone: NgZone, tooltipService: TooltipService, viewContainerRef: ViewContainerRef, renderer: Renderer2, element: ElementRef<HTMLElement>);
    ngOnDestroy(): void;
    onFocus(): void;
    onBlur(): void;
    onMouseEnter(): void;
    onMouseLeave(event: {
        toElement: Node;
    }): void;
    onMouseClick(): void;
    showTooltip(immediate?: boolean): void;
    hideTooltip(immediate?: boolean): void;
    addHideListeners(tooltip: HTMLElement): void;
    private createBoundOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[ngx-tooltip]", ["ngxTooltip"], { "tooltipCssClass": { "alias": "tooltipCssClass"; "required": false; }; "tooltipTitle": { "alias": "tooltipTitle"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipAlignment": { "alias": "tooltipAlignment"; "required": false; }; "tooltipType": { "alias": "tooltipType"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "tooltipShowEvent": { "alias": "tooltipShowEvent"; "required": false; }; "tooltipContext": { "alias": "tooltipContext"; "required": false; }; "tooltipSpacing": { "alias": "tooltipSpacing"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipShowCaret": { "alias": "tooltipShowCaret"; "required": false; }; "tooltipCloseOnClickOutside": { "alias": "tooltipCloseOnClickOutside"; "required": false; }; "tooltipCloseOnMouseLeave": { "alias": "tooltipCloseOnMouseLeave"; "required": false; }; "tooltipHideTimeout": { "alias": "tooltipHideTimeout"; "required": false; }; "tooltipShowTimeout": { "alias": "tooltipShowTimeout"; "required": false; }; }, { "show": "show"; "hide": "hide"; }, never, never, false, never>;
}

declare class TooltipModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TooltipModule, [typeof TooltipContentComponent, typeof TooltipDirective], [typeof i2.CommonModule], [typeof TooltipContentComponent, typeof TooltipDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TooltipModule>;
}

declare class InputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InputModule, [typeof InputComponent, typeof InputHintDirective, typeof AutosizeDirective, typeof InputPrefixComponent, typeof InputSuffixComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof AutoSizeInputModule, typeof TooltipModule], [typeof InputComponent, typeof InputHintDirective, typeof InputPrefixComponent, typeof InputSuffixComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InputModule>;
}

declare class CalendarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CalendarModule, [typeof CalendarComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i4$1.MomentModule, typeof PipesModule, typeof InputModule], [typeof CalendarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CalendarModule>;
}

declare enum CardStatus {
    Success = "success",
    Error = "error",
    Disabled = "disabled"
}

declare enum CardOrientation {
    Horizontal = "horizontal",
    Vertical = "vertical"
}

declare enum CardAppearance {
    Normal = "normal",
    Flat = "flat"
}

declare class CardComponent {
    get horizontal(): boolean;
    get vertical(): boolean;
    get flat(): boolean;
    disabled: boolean;
    orientation: CardOrientation;
    status: CardStatus;
    statusTooltip: string;
    selectable: boolean;
    selected: boolean;
    error: boolean;
    outlineText: string;
    appearance: CardAppearance;
    hideAccent: boolean;
    select: EventEmitter<boolean>;
    outlineClick: EventEmitter<void>;
    onOutlineClick($event: any): void;
    onSelect($event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardComponent, "ngx-card", ["ngxCard"], { "disabled": { "alias": "disabled"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "status": { "alias": "status"; "required": false; }; "statusTooltip": { "alias": "statusTooltip"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "error": { "alias": "error"; "required": false; }; "outlineText": { "alias": "outlineText"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "hideAccent": { "alias": "hideAccent"; "required": false; }; }, { "select": "select"; "outlineClick": "outlineClick"; }, never, ["*"], false, never>;
}

declare class CardHeaderComponent {
    label: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardHeaderComponent, "ngx-card-header", ["ngxCardHeader"], { "label": { "alias": "label"; "required": false; }; }, {}, never, ["ngx-card-avatar", "*", "ngx-card-tag", "ngx-card-title", "ngx-card-subtitle"], false, never>;
}

declare class CardBodyDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardBodyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardBodyDirective, "ngx-card-body, [ngxCardBody], [ngx-card-body]", never, {}, {}, never, never, false, never>;
}
declare class CardTagDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardTagDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardTagDirective, "ngx-card-tag, [ngxCardTag], [ngx-card-tag]", never, {}, {}, never, never, false, never>;
}
declare class CardTitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardTitleDirective, "ngx-card-title, [ngxCardTitle], [ngx-card-title]", never, {}, {}, never, never, false, never>;
}
declare class CardSubtitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardSubtitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardSubtitleDirective, "ngx-card-subtitle, [ngxCardSubtitle], [ngx-card-subtitle]", never, {}, {}, never, never, false, never>;
}
declare class CardSectionDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardSectionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CardSectionDirective, "ngx-card-section, [ngxCardSection], [ngx-card-section]", never, {}, {}, never, never, false, never>;
}

declare class CardAvatarComponent {
    src: string | SafeUrl;
    status: CardStatus;
    removeImageBackground?: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardAvatarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardAvatarComponent, "ngx-card-avatar", ["ngxCardAvatar"], { "src": { "alias": "src"; "required": false; }; "status": { "alias": "status"; "required": false; }; "removeImageBackground": { "alias": "removeImageBackground"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class CardFooterComponent {
    label: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardFooterComponent, "ngx-card-footer", ["ngxCardFooter"], { "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare enum CardPlaceholderSize {
    Small = "small",
    Medium = "medium",
    Large = "large"
}
declare class CardPlaceholderComponent {
    size: CardPlaceholderSize;
    readonly CardPlaceholderSize: typeof CardPlaceholderSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<CardPlaceholderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CardPlaceholderComponent, "ngx-card-placeholder", ["ngxCardPlaceholder"], { "size": { "alias": "size"; "required": false; }; }, {}, never, never, false, never>;
}

declare class IconComponent implements OnChanges, OnInit {
    private http;
    private elementRef;
    private iconRegisteryService;
    fontIcon: string | string[];
    alt: string;
    defaultPath: string;
    fontSet: string;
    set svgSrc(val: string);
    cssClasses: string[];
    constructor(http: HttpClient, elementRef: ElementRef, iconRegisteryService: IconRegistryService);
    ngOnChanges(): void;
    ngOnInit(): void;
    update(): void;
    loadSvg(val: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IconComponent, "ngx-icon", ["ngxIcon"], { "fontIcon": { "alias": "fontIcon"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; "defaultPath": { "alias": "defaultPath"; "required": false; }; "fontSet": { "alias": "fontSet"; "required": false; }; "svgSrc": { "alias": "svgSrc"; "required": false; }; }, {}, never, ["*", "*"], false, never>;
}

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

declare class CheckboxComponent implements ControlValueAccessor {
    private readonly cdr;
    onClick(ev: Event): void;
    id: string;
    name?: string;
    diameter: string;
    set value(value: boolean);
    get value(): boolean;
    set indeterminate(value: boolean);
    get indeterminate(): boolean;
    tabindex: number;
    disabled: boolean;
    round: boolean;
    change: EventEmitter<Event>;
    checkedChange: EventEmitter<boolean>;
    indeterminateChange: EventEmitter<boolean>;
    blur: EventEmitter<FocusEvent>;
    focus: EventEmitter<FocusEvent>;
    private _value;
    private _indeterminate;
    constructor(cdr: ChangeDetectorRef);
    onBlur(_: any): void;
    onKeyup(ev: Event): void;
    toggle(): void;
    writeValue(value: boolean): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(disabled: boolean): void;
    private onTouchedCallback;
    private onChangeCallback;
    private emitChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "ngx-checkbox", ["ngxCheckbox"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "value": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "round": { "alias": "round"; "required": false; }; }, { "change": "change"; "checkedChange": "checkedChange"; "indeterminateChange": "indeterminateChange"; "blur": "blur"; "focus": "focus"; }, never, ["*"], false, never>;
}

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

declare class CardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CardModule, [typeof CardComponent, typeof CardHeaderComponent, typeof CardBodyDirective, typeof CardTagDirective, typeof CardTitleDirective, typeof CardSubtitleDirective, typeof CardSectionDirective, typeof CardAvatarComponent, typeof CardFooterComponent, typeof CardPlaceholderComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof IconModule, typeof TooltipModule, typeof CheckboxModule], [typeof CardComponent, typeof CardHeaderComponent, typeof CardBodyDirective, typeof CardTagDirective, typeof CardTitleDirective, typeof CardSubtitleDirective, typeof CardSectionDirective, typeof CardAvatarComponent, typeof CardFooterComponent, typeof CardPlaceholderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CardModule>;
}

interface HintCompletion {
    text: string;
    displayText: string;
    className: string;
}

declare class CodeEditorComponent implements OnInit, AfterViewInit, ControlValueAccessor {
    private readonly renderer;
    config: any;
    theme: string;
    readOnly: string | boolean;
    allowDropFileTypes: string[];
    gutters: Array<string | {
        className: string;
        style?: string;
    }>;
    mode?: any;
    lint?: any;
    autocompleteTokens?: Array<string | HintCompletion>;
    get autofocus(): boolean;
    set autofocus(autofocus: boolean);
    get lineNumbers(): boolean;
    set lineNumbers(lineNumbers: boolean);
    change: EventEmitter<any>;
    blur: EventEmitter<any>;
    host: any;
    content: any;
    instance: CodeMirror.EditorFromTextArea;
    _value: string;
    get value(): string;
    set value(val: string);
    private _autofocus;
    private _lineNumbers;
    constructor(renderer: Renderer2);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    cleanCode(code: string): string;
    onVisible(): void;
    onKeyUp(cm: CodeMirror.EditorFromTextArea, event: KeyboardEvent): void;
    onChange(): void;
    onBlur(): void;
    updateValue(value: string): void;
    writeValue(val: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    private onTouchedCallback;
    private onChangeCallback;
    private autocomplete;
    static ɵfac: i0.ɵɵFactoryDeclaration<CodeEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CodeEditorComponent, "ngx-codemirror", ["ngxCodemirror"], { "config": { "alias": "config"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "allowDropFileTypes": { "alias": "allowDropFileTypes"; "required": false; }; "gutters": { "alias": "gutters"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "lint": { "alias": "lint"; "required": false; }; "autocompleteTokens": { "alias": "autocompleteTokens"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "lineNumbers": { "alias": "lineNumbers"; "required": false; }; }, { "change": "change"; "blur": "blur"; }, never, ["*"], false, never>;
}

declare class DirectivesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DirectivesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DirectivesModule, never, [typeof i2.CommonModule, typeof VisibilityModule, typeof DblClickCopyModule, typeof LongPressModule, typeof PatternValidatorModule], [typeof VisibilityModule, typeof DblClickCopyModule, typeof LongPressModule, typeof PatternValidatorModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DirectivesModule>;
}

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

/**
 * Overlay Component for Drawer/Dialogs
 */
declare class OverlayComponent {
    private readonly cdr;
    get visible(): boolean;
    set visible(val: boolean);
    get zIndex(): number;
    set zIndex(val: number);
    click: EventEmitter<boolean>;
    get animationState(): string;
    private _visible;
    private _zIndex;
    constructor(cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OverlayComponent, "ngx-overlay", ["ngxOverlay"], { "visible": { "alias": "visible"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; }, { "click": "click"; }, never, ["*"], false, never>;
}

declare class OverlayService {
    private injectionService;
    component: ComponentRef<OverlayComponent>;
    triggerComponents: any[];
    click: any;
    get instance(): OverlayComponent;
    constructor(injectionService: InjectionService);
    show(options?: any): ComponentRef<OverlayComponent>;
    hide(): void;
    destroy(): void;
    injectComponent(): ComponentRef<OverlayComponent>;
    onClick(): void;
    removeTriggerComponent(component: any): void;
    updateZIndex(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayService>;
}

declare enum AlertStyles {
    Danger = "danger",
    Warning = "warning",
    Info = "info"
}

declare enum AlertTypes {
    Alert = "alert",
    Confirm = "confirm",
    Prompt = "prompt"
}

declare enum DialogFormat {
    Regular = "regular",
    Medium = "medium",
    Large = "large"
}

interface DialogOptions extends PartialBindings {
    readonly title?: string;
    readonly content?: string;
    readonly template?: TemplateRef<any>;
    readonly cssClass?: string;
    readonly context?: any;
    readonly class?: string;
    readonly closeOnBlur?: boolean;
    readonly closeOnEscape?: boolean;
    readonly closeButton?: boolean;
    readonly visible?: boolean;
    readonly longPress?: boolean;
    readonly showOverlay?: boolean;
    readonly zIndex?: number;
    readonly type?: AlertTypes;
    readonly style?: AlertStyles;
    readonly confirmButtonText?: string;
    readonly confirmButtonClass?: string | string[];
    readonly cancelButtonText?: string;
    readonly cancelButtonClass?: string | string[];
    readonly format?: DialogFormat;
    readonly beforeClose?: any;
    readonly inputs?: {
        title?: string;
        content?: string;
        template?: TemplateRef<any>;
        cssClass?: string;
        context?: any;
        class?: string;
        closeOnBlur?: boolean;
        closeOnEscape?: boolean;
        closeButton?: boolean;
        visible?: boolean;
        longPress?: boolean;
        showOverlay?: boolean;
        zIndex?: number;
        type?: AlertTypes;
        style?: AlertStyles;
    };
}

declare class DialogComponent implements OnInit, OnDestroy {
    private readonly element;
    private readonly renderer2;
    id: string;
    title: string;
    dialogTitle: string;
    content: string;
    template: TemplateRef<any>;
    cssClass: string;
    context: any;
    class: string;
    format: DialogFormat;
    get closeOnBlur(): boolean;
    set closeOnBlur(closeOnBlur: boolean);
    get closeOnEscape(): boolean;
    set closeOnEscape(closeOnEscape: boolean);
    get closeButton(): boolean;
    set closeButton(closeButton: boolean);
    get visible(): boolean;
    set visible(visible: boolean);
    get zIndex(): number;
    set zIndex(zIndex: number);
    beforeClose: () => boolean;
    open: EventEmitter<boolean | void>;
    close: EventEmitter<boolean | void>;
    get contentzIndex(): number;
    get visibleState(): "active" | "inactive";
    get canClose(): boolean;
    readonly DialogFormat: typeof DialogFormat;
    private _closeOnBlur?;
    private _closeOnEscape?;
    private _closeButton?;
    private _visible?;
    private _zIndex?;
    constructor(element: ElementRef, renderer2: Renderer2);
    ngOnInit(): void;
    ngOnDestroy(): void;
    show(): void;
    hide(): void;
    onEscapeKeyDown(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "ngx-dialog", ["ngxDialog"], { "id": { "alias": "id"; "required": false; }; "title": { "alias": "title"; "required": false; }; "dialogTitle": { "alias": "dialogTitle"; "required": false; }; "content": { "alias": "content"; "required": false; }; "template": { "alias": "template"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "context": { "alias": "context"; "required": false; }; "class": { "alias": "class"; "required": false; }; "format": { "alias": "format"; "required": false; }; "closeOnBlur": { "alias": "closeOnBlur"; "required": false; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; }; "closeButton": { "alias": "closeButton"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "beforeClose": { "alias": "beforeClose"; "required": false; }; }, { "open": "open"; "close": "close"; }, never, ["*"], false, never>;
}

declare class DialogService<T = DialogComponent> extends InjectionRegistryService<T> {
    readonly injectionService: InjectionService;
    readonly overlayService: OverlayService;
    readonly defaults: DialogOptions;
    protected type: any;
    private zIndex;
    constructor(injectionService: InjectionService, overlayService: OverlayService);
    create(options: DialogOptions): i0.ComponentRef<T>;
    destroy(component: any): void;
    createSubscriptions(triggerComponent: any): void;
    assignDefaults(options: DialogOptions): DialogOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService<any>>;
}

type Datelike = string | Date | Moment;

declare enum NotificationStyleType {
    info = "info",
    warning = "warning",
    error = "error",
    success = "success",
    none = "none"
}

declare class NotificationComponent {
    cssClass: string;
    title: string;
    body: string;
    template: TemplateRef<any>;
    styleType: NotificationStyleType;
    icon: string;
    timeout: false | number;
    get showClose(): boolean;
    set showClose(showClose: boolean);
    get pauseOnHover(): boolean;
    set pauseOnHover(pauseOnHover: boolean);
    get timestamp(): number;
    set timestamp(timestamp: number);
    close: EventEmitter<void>;
    pause: EventEmitter<void>;
    resume: EventEmitter<void>;
    get cssClasses(): string;
    get animationDuration(): string;
    readonly NotificationStyleType: typeof NotificationStyleType;
    timer: any;
    private _showClose?;
    private _pauseOnHover?;
    private _timestamp?;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "ngx-notification", ["ngxNotification"], { "cssClass": { "alias": "cssClass"; "required": false; }; "title": { "alias": "title"; "required": false; }; "body": { "alias": "body"; "required": false; }; "template": { "alias": "template"; "required": false; }; "styleType": { "alias": "styleType"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "timeout": { "alias": "timeout"; "required": false; }; "showClose": { "alias": "showClose"; "required": false; }; "pauseOnHover": { "alias": "pauseOnHover"; "required": false; }; "timestamp": { "alias": "timestamp"; "required": false; }; }, { "close": "close"; "pause": "pause"; "resume": "resume"; }, never, never, false, never>;
}

declare class NotificationContainerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationContainerComponent, "ngx-notification-container", ["ngxNotificationContainer"], {}, {}, never, never, false, never>;
}

declare enum NotificationType {
    html = "html",
    native = "native"
}

interface NotificationOptions {
    readonly cssClass?: string;
    readonly title?: string;
    readonly body?: string;
    readonly template?: TemplateRef<any>;
    readonly pauseOnHover?: boolean;
    readonly type?: NotificationType;
    readonly styleType?: NotificationStyleType;
    readonly showClose?: boolean;
    readonly timestamp?: number;
    readonly icon?: string;
    readonly timeout?: number | boolean;
    readonly rateLimit?: boolean;
    readonly sound?: boolean;
    readonly inputs?: {
        cssClass?: string;
        title?: string;
        body?: string;
        template?: TemplateRef<any>;
        pauseOnHover?: boolean;
        type?: NotificationType;
        styleType?: NotificationStyleType;
        showClose?: boolean;
        timestamp?: number;
        icon?: string;
        timeout?: number | boolean;
        rateLimit?: boolean;
        sound?: boolean;
    };
}

/** adding dynamic to suppress `Document` type metadata error  */
/** @dynamic */
declare class NotificationService extends InjectionRegistryService<NotificationComponent> {
    readonly injectionService: InjectionService;
    private readonly document;
    static readonly limit: number | boolean;
    readonly defaults: NotificationOptions;
    permission: NotificationPermission;
    container?: ComponentRef<NotificationContainerComponent>;
    type: typeof NotificationComponent;
    get isNativeSupported(): boolean;
    constructor(injectionService: InjectionService, document: Document);
    create(bindings: Partial<NotificationOptions>): ComponentRef<NotificationComponent>;
    startTimer(component: ComponentRef<NotificationComponent>): void;
    pauseTimer(component: ComponentRef<NotificationComponent>): void;
    requestPermissions(): void;
    assignDefaults(options: Partial<NotificationOptions>): PartialBindings;
    injectComponent(type: Type<NotificationContainerComponent>, options: PartialBindings): ComponentRef<any>;
    createSubscriptions(component: ComponentRef<NotificationComponent>): any;
    isFlooded(options: Partial<NotificationOptions>): boolean;
    showNative(options: Partial<NotificationOptions>): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
}

declare const DATE_DISPLAY_FORMATS: {
    shortDate: string;
    shortTime: string;
    shortDateTime: string;
    shortDateTimeSeconds: string;
    date: string;
    time: string;
    dateTime: string;
    dateTimeSeconds: string;
    dateMonth: string;
    dateYear: string;
    fullDate: string;
    fullTime: string;
    fullDateTime: string;
    fullDateMonth: string;
    fullDateYear: string;
    localeDate: string;
    localeDateTime: string;
    localeTime: string;
    timezoneDate: string;
    timezoneDateTime: string;
    timezoneDateTimeSeconds: string;
    timezoneTime: string;
    timezoneDateMonth: string;
    timezoneDateYear: string;
    locale: string;
    shortLocale: string;
    fullLocale: string;
};
declare const DATE_DISPLAY_INPUT_FORMATS: Array<string | moment.MomentBuiltinFormat>;
declare enum DATE_DISPLAY_TYPES {
    HUMAN = "human",
    TIMEZONE = "timezone",
    LOCAL = "local",
    CUSTOM = "custom"
}

declare class DateTimeComponent implements OnDestroy, OnChanges, ControlValueAccessor, Validator {
    private readonly dialogService;
    private readonly cdr;
    private readonly clipboard;
    private readonly notificationService;
    id: string;
    name: string;
    label: string;
    hint: string;
    placeholder: string;
    size: Size;
    appearance: Appearance;
    withMargin: boolean;
    precision: moment.unitOfTime.StartOf;
    timezone: string;
    inputFormats: any[];
    set value(val: Date | string);
    get value(): Date | string;
    disabled: boolean;
    minWidth: number;
    tabindex: number;
    autofocus: boolean;
    set inputType(val: string);
    get inputType(): string;
    /**
     * Display mode for date/time
     * 'timezone' - display date/time with a timezone
     * 'local' - display date/time without timezone
     *
     * Defaults to LOCAL unless timezone is set
     */
    set displayMode(val: DATE_DISPLAY_TYPES);
    get displayMode(): DATE_DISPLAY_TYPES;
    /**
     * Display format for date/time
     * Considers if mode is user (has timezone), local (no timezone)
     */
    set format(val: string);
    get format(): string;
    set tooltipFormat(val: string);
    get tooltipFormat(): string;
    tooltipDisabled: boolean;
    get hasPopup(): boolean;
    dateInvalid: boolean;
    dateOutOfRange: boolean;
    /**
     * Used to display date in other timezones
     *
     * Only used if displayMode is 'user' or timezone is set
     */
    timezones: Record<string, string>;
    tooltipCssClass: string;
    set clipFormat(val: string);
    get clipFormat(): string;
    requiredIndicator: string | boolean;
    required: boolean;
    get displayValue(): string;
    set displayValue(value: string);
    autosize: boolean;
    minDate: Date | string;
    maxDate: Date | string;
    /**
     * this output will emit only when the input value is valid or cleared.
     */
    change: EventEmitter<string | Date>;
    /**
     * this output will emit anytime the value changes regardless of validity.
     */
    valueChange: EventEmitter<string | Date>;
    /**
     * this output will emit anytime the value changes in the input, regardless of validity.
     */
    inputChange: EventEmitter<string | Date>;
    /**
     * this output will emit a date is selected from the calendar
     */
    dateTimeSelected: EventEmitter<string | Date>;
    blur: EventEmitter<Event>;
    focus: EventEmitter<Event>;
    readonly calendarTpl: TemplateRef<ElementRef>;
    readonly input: InputComponent;
    readonly calendar: CalendarComponent;
    readonly tooltip: TooltipDirective;
    dialog: any;
    dialogModel: moment.Moment;
    hour: number;
    minute: string;
    second: string;
    millisecond: string;
    amPmVal: string;
    modes: string[];
    timeValues: {};
    private _value;
    private _displayValue;
    private _format;
    private _tooltipFormat;
    private _inputType;
    private _displayMode;
    private _clipFormat;
    private _focused;
    constructor(dialogService: DialogService, cdr: ChangeDetectorRef, clipboard: Clipboard, notificationService: NotificationService);
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(val: any): void;
    onFocus(event?: Event): void;
    onBlur(event?: Event): void;
    open(): void;
    apply(): void;
    setDialogDate(date: Datelike): void;
    minuteChanged(newVal: number): void;
    secondChanged(newVal: number): void;
    millisecondChanged(newVal: number): void;
    hourChanged(newVal: number): void;
    selectCurrent(): void;
    isCurrent(): boolean;
    clear(): void;
    onAmPmChange(newVal: string): void;
    getDayDisabled(date: moment.Moment): boolean;
    isTimeDisabled(mode: moment.unitOfTime.StartOf): boolean;
    inputChanged(val: string): void;
    close(): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onClick(item: any): void;
    validate(c: UntypedFormControl): ValidationErrors | null;
    setDisabledState(isDisabled: boolean): void;
    onTouchedCallback: () => void;
    onChangeCallback: (_: any) => void;
    onInputKeyDown(event: KeyboardEvent): void;
    private roundTo;
    private parseDate;
    private createMoment;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeComponent, "ngx-date-time", ["ngxDateTime"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "size": { "alias": "size"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "withMargin": { "alias": "withMargin"; "required": false; }; "precision": { "alias": "precision"; "required": false; }; "timezone": { "alias": "timezone"; "required": false; }; "inputFormats": { "alias": "inputFormats"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "inputType": { "alias": "inputType"; "required": false; }; "displayMode": { "alias": "displayMode"; "required": false; }; "format": { "alias": "format"; "required": false; }; "tooltipFormat": { "alias": "tooltipFormat"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "timezones": { "alias": "timezones"; "required": false; }; "tooltipCssClass": { "alias": "tooltipCssClass"; "required": false; }; "clipFormat": { "alias": "clipFormat"; "required": false; }; "requiredIndicator": { "alias": "requiredIndicator"; "required": false; }; "required": { "alias": "required"; "required": false; }; "autosize": { "alias": "autosize"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "change": "change"; "valueChange": "valueChange"; "inputChange": "inputChange"; "dateTimeSelected": "dateTimeSelected"; "blur": "blur"; "focus": "focus"; }, never, never, false, never>;
}

declare class AlertComponent extends DialogComponent implements AfterViewInit, OnInit {
    type: AlertTypes;
    data: any;
    confirmButtonText: string;
    confirmButtonClass: string | string[];
    cancelButtonText: string;
    cancelButtonClass: string | string[];
    get longPress(): boolean;
    set longPress(longPress: boolean);
    ok: EventEmitter<{
        data: any;
    }>;
    cancel: EventEmitter<{
        data: any;
    }>;
    readonly dialogElm: ElementRef<HTMLDivElement>;
    readonly AlertTypes: typeof AlertTypes;
    readonly defaults: DialogOptions;
    private _longPress?;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onOkClick(): void;
    onCancelClick(): void;
    onKeydown(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AlertComponent, "ngx-alert-dialog", ["ngxAlertDialog"], { "type": { "alias": "type"; "required": false; }; "data": { "alias": "data"; "required": false; }; "confirmButtonText": { "alias": "confirmButtonText"; "required": false; }; "confirmButtonClass": { "alias": "confirmButtonClass"; "required": false; }; "cancelButtonText": { "alias": "cancelButtonText"; "required": false; }; "cancelButtonClass": { "alias": "cancelButtonClass"; "required": false; }; "longPress": { "alias": "longPress"; "required": false; }; }, { "ok": "ok"; "cancel": "cancel"; }, never, never, false, never>;
}

declare class AlertService extends DialogService<AlertComponent> {
    readonly injectionService: InjectionService;
    readonly overlayService: OverlayService;
    readonly defaults: DialogOptions;
    protected type: any;
    constructor(injectionService: InjectionService, overlayService: OverlayService);
    alert(options: DialogOptions): Subject<{
        type: string;
        data: any;
    }>;
    confirm(options: DialogOptions): Subject<{
        type: string;
        data: any;
    }>;
    prompt(options: DialogOptions): Subject<{
        type: string;
        data: any;
    }>;
    private createDialog;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AlertService>;
}

declare class LargeFormatDialogFooterComponent {
    elementRef: ElementRef;
    styleClass?: string;
    format: 'large' | 'medium';
    get footerStyle(): string;
    get isLargeFormat(): boolean;
    get isMediumFormat(): boolean;
    constructor(elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<LargeFormatDialogFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LargeFormatDialogFooterComponent, "ngx-large-format-dialog-footer, ngx-medium-format-dialog-footer", never, { "styleClass": { "alias": "styleClass"; "required": false; }; "format": { "alias": "format"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class LargeFormatDialogContentComponent implements OnInit {
    elementRef: ElementRef;
    private readonly alertService;
    dialogTitle: string;
    dialogSubtitle?: string;
    imgSrc?: string | SafeUrl;
    removeImageBackground?: boolean;
    logoTemplate?: TemplateRef<unknown>;
    dialogSubtitleTemplate?: TemplateRef<unknown>;
    format: 'large' | 'medium';
    dialogActionTitle: string;
    dirty: boolean;
    dialogDirtyActionTitle: string;
    dirtyAlertOptions?: DialogOptions;
    skipDirtyAlert: boolean;
    closeOrCancel: EventEmitter<boolean>;
    get isLargeFormat(): boolean;
    get isMediumFormat(): boolean;
    footerComponent?: LargeFormatDialogFooterComponent;
    stepperTemplate?: TemplateRef<unknown>;
    tabsTemplate?: TemplateRef<unknown>;
    myTemplate: ElementRef;
    imageTemplate: {};
    constructor(elementRef: ElementRef, alertService: AlertService);
    ngOnInit(): void;
    onCloseOrCancel(isDirty: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LargeFormatDialogContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LargeFormatDialogContentComponent, "ngx-large-format-dialog-content, ngx-medium-format-dialog-content", never, { "dialogTitle": { "alias": "dialogTitle"; "required": false; }; "dialogSubtitle": { "alias": "dialogSubtitle"; "required": false; }; "imgSrc": { "alias": "imgSrc"; "required": false; }; "removeImageBackground": { "alias": "removeImageBackground"; "required": false; }; "logoTemplate": { "alias": "logoTemplate"; "required": false; }; "dialogSubtitleTemplate": { "alias": "dialogSubtitleTemplate"; "required": false; }; "format": { "alias": "format"; "required": false; }; "dialogActionTitle": { "alias": "dialogActionTitle"; "required": false; }; "dirty": { "alias": "dirty"; "required": false; }; "dialogDirtyActionTitle": { "alias": "dialogDirtyActionTitle"; "required": false; }; "dirtyAlertOptions": { "alias": "dirtyAlertOptions"; "required": false; }; "skipDirtyAlert": { "alias": "skipDirtyAlert"; "required": false; }; }, { "closeOrCancel": "closeOrCancel"; }, ["footerComponent", "stepperTemplate", "tabsTemplate"], ["*", "ngx-large-format-dialog-footer", "ngx-medium-format-dialog-footer"], false, never>;
}

declare class LargeFormatDialogHeaderTitleComponent {
    elementRef: ElementRef;
    format: 'large' | 'medium';
    dialogTitle: string;
    dialogSubtitle?: string;
    imageTemplate: any;
    dialogSubtitleTemplate: TemplateRef<unknown>;
    get isLargeFormat(): boolean;
    get isMediumFormat(): boolean;
    constructor(elementRef: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<LargeFormatDialogHeaderTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LargeFormatDialogHeaderTitleComponent, "ngx-large-format-dialog-header-title, ngx-medium-format-dialog-header-title", never, { "format": { "alias": "format"; "required": false; }; "dialogTitle": { "alias": "dialogTitle"; "required": false; }; "dialogSubtitle": { "alias": "dialogSubtitle"; "required": false; }; "imageTemplate": { "alias": "imageTemplate"; "required": false; }; "dialogSubtitleTemplate": { "alias": "dialogSubtitleTemplate"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LargeFormatDialogHeaderActionComponent {
    actionTitle: string;
    dirty: boolean;
    dirtyActionTitle: string;
    closeOrCancel: EventEmitter<boolean>;
    hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LargeFormatDialogHeaderActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LargeFormatDialogHeaderActionComponent, "ngx-large-format-dialog-header-action", never, { "actionTitle": { "alias": "actionTitle"; "required": false; }; "dirty": { "alias": "dirty"; "required": false; }; "dirtyActionTitle": { "alias": "dirtyActionTitle"; "required": false; }; }, { "closeOrCancel": "closeOrCancel"; }, never, never, false, never>;
}

declare class LargeFormatDialogStepperDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<LargeFormatDialogStepperDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LargeFormatDialogStepperDirective, "ng-template[largeFormatDialogStepper]", never, {}, {}, never, never, false, never>;
}

declare class LargeFormatDialogSubStepperDirective {
    hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LargeFormatDialogSubStepperDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LargeFormatDialogSubStepperDirective, "ngx-stepper[largeFormatDialogSubStepper]", never, {}, {}, never, never, false, never>;
}

declare class LargeFormatDialogTabsDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<LargeFormatDialogTabsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LargeFormatDialogTabsDirective, "ng-template[largeFormatDialogTabs]", never, {}, {}, never, never, false, never>;
}

declare class LargeFormatDialogSubTabsDirective {
    hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LargeFormatDialogSubTabsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LargeFormatDialogSubTabsDirective, "ngx-tabs[largeFormatDialogSubTabs]", never, {}, {}, never, never, false, never>;
}

interface Hotkey {
    readonly callback: (..._: any[]) => void;
    readonly description: string;
    readonly component: any;
    readonly zone?: NgZone;
    status?: string;
    keys?: string[];
    visible?: boolean;
    allowIn?: string[];
}

declare function _add(combo: string, opts: Hotkey): Hotkey;
declare function _suspend(comp: any): void;
declare function _pauseOthers(comp?: any): void;
declare function _unpauseOthers(comp?: any): void;
declare function _activate(comp: any): void;
declare function _deregister(comp: any): void;
declare function HotKey(key: string, description: string, options?: Partial<Hotkey>): (target: any, name: string) => void;
declare class HotkeysService {
    private readonly ngZone;
    readonly suspend: typeof _suspend;
    readonly activate: typeof _activate;
    readonly deregister: typeof _deregister;
    readonly pauseOthers: typeof _pauseOthers;
    readonly unpauseOthers: typeof _unpauseOthers;
    readonly changeEvent: rxjs.Observable<{
        [combo: string]: Hotkey[];
    }>;
    get hotKeys(): {
        [combo: string]: Hotkey[];
    };
    constructor(ngZone: NgZone);
    add(combo: string, opts: Hotkey): Hotkey;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HotkeysService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HotkeysService>;
}

declare class ResizeOverlayComponent implements OnInit, OnDestroy {
    private breakpointObserver;
    private hotkeysService;
    private cdr;
    combo: string;
    get query(): string;
    set query(value: string);
    set disabled(value: boolean);
    get disabled(): boolean;
    visible$: Observable<boolean>;
    private _disabled;
    private _query;
    get keys(): string[];
    constructor(breakpointObserver: BreakpointObserver, hotkeysService: HotkeysService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onClick(ev: KeyboardEvent): void;
    toggle(): void;
    private _buildObservable;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeOverlayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResizeOverlayComponent, "ngx-resize-overlay", ["ngxResizeOverlay"], { "combo": { "alias": "combo"; "required": false; }; "query": { "alias": "query"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class OverlayModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<OverlayModule, [typeof OverlayComponent, typeof ResizeOverlayComponent], [typeof i2.CommonModule, typeof IconModule, typeof i5.LayoutModule], [typeof OverlayComponent, typeof ResizeOverlayComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<OverlayModule>;
}

declare enum LongPressButtonState {
    Active = "active",
    Submitted = "submitted"
}

declare class LongPressButtonComponent implements OnInit, OnChanges {
    private readonly cdr;
    state: LongPressButtonState;
    icon: string;
    get duration(): number;
    set duration(duration: number);
    get disabled(): boolean;
    set disabled(disabled: boolean);
    longPress: EventEmitter<boolean>;
    readonly LongPressButtonState: typeof LongPressButtonState;
    pressed: boolean;
    private _lastTimeout;
    private _duration;
    private _disabled;
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(): void;
    updateState(): void;
    onLongPressStart(): void;
    onLongPressFinish(e: boolean): void;
    onLongPressCancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LongPressButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LongPressButtonComponent, "ngx-long-press-button", ["ngxLongPressButton"], { "state": { "alias": "state"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "duration": { "alias": "duration"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "longPress": "longPress"; }, never, never, false, never>;
}

declare class LongPressButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LongPressButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LongPressButtonModule, [typeof LongPressButtonComponent], [typeof i2.CommonModule, typeof IconModule, typeof DirectivesModule], [typeof LongPressButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LongPressButtonModule>;
}

declare class DialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogModule, [typeof DialogComponent, typeof AlertComponent, typeof LargeFormatDialogContentComponent, typeof LargeFormatDialogHeaderTitleComponent, typeof LargeFormatDialogHeaderActionComponent, typeof LargeFormatDialogFooterComponent, typeof LargeFormatDialogStepperDirective, typeof LargeFormatDialogSubStepperDirective, typeof LargeFormatDialogTabsDirective, typeof LargeFormatDialogSubTabsDirective], [typeof i2.CommonModule, typeof OverlayModule, typeof InputModule, typeof i3.FormsModule, typeof LongPressButtonModule], [typeof DialogComponent, typeof AlertComponent, typeof LargeFormatDialogContentComponent, typeof LargeFormatDialogFooterComponent, typeof LargeFormatDialogStepperDirective, typeof LargeFormatDialogSubStepperDirective, typeof LargeFormatDialogTabsDirective, typeof LargeFormatDialogSubTabsDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DialogModule>;
}

declare class ToggleComponent implements ControlValueAccessor {
    private readonly cdr;
    onClick(ev: Event): void;
    id: string;
    name: string;
    label: string;
    get disabled(): boolean;
    set disabled(disabled: boolean);
    get required(): boolean;
    set required(required: boolean);
    get showIcons(): boolean;
    set showIcons(showIcons: boolean);
    get tabIndex(): number;
    set tabIndex(tabIndex: number);
    change: EventEmitter<Event>;
    get value(): boolean;
    set value(value: boolean);
    get getHostCssClasses(): string;
    get getDisabled(): string;
    private _value;
    private _disabled;
    private _required;
    private _showIcons;
    private _tabIndex;
    constructor(cdr: ChangeDetectorRef);
    toggle(): void;
    onBlur(): void;
    writeValue(val: unknown): void;
    registerOnChange(fn: (_: unknown) => void): void;
    registerOnTouched(fn: () => void): void;
    private onTouchedCallback;
    private onChangeCallback;
    private emitChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleComponent, "ngx-toggle", ["ngxToggle"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "showIcons": { "alias": "showIcons"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "change": "change"; }, never, ["*"], false, never>;
}

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

declare class DateTimeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DateTimeModule, [typeof DateTimeComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof InputModule, typeof DialogModule, typeof i4$1.MomentModule, typeof CalendarModule, typeof ToggleModule, typeof PipesModule, typeof TooltipModule, typeof IconModule], [typeof DateTimeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DateTimeModule>;
}

declare enum DateTimeType {
    date = "date",
    time = "time",
    datetime = "datetime"
}

declare class NgxTimeDisplayComponent implements OnInit, OnChanges {
    private readonly clipboard;
    private readonly notificationService;
    datetime: Datelike;
    precision: moment.unitOfTime.StartOf;
    timezone: string;
    defaultInputTimeZone: string;
    set mode(val: DATE_DISPLAY_TYPES);
    get mode(): DATE_DISPLAY_TYPES;
    set type(val: string);
    get type(): string;
    set format(val: string);
    get format(): string;
    set tooltipFormat(val: string);
    get tooltipFormat(): string;
    set clipFormat(val: string);
    get clipFormat(): string;
    timezones: Record<string, string>;
    tooltipTemplate: string;
    tooltipDisabled: boolean;
    tooltipCssClass: string;
    tooltipPlacement: string;
    defaultCopyKey: string;
    invalidDateMessage: string;
    get clickable(): boolean;
    set clickable(val: boolean);
    get hasPopup(): boolean;
    dateInvalid: boolean;
    timeValues: {};
    titleValue: string;
    internalDatetime: Date;
    utcDatetime: string;
    readonly DATE_DISPLAY_TYPES: typeof DATE_DISPLAY_TYPES;
    readonly DATE_DISPLAY_FORMATS: {
        shortDate: string;
        shortTime: string;
        shortDateTime: string;
        shortDateTimeSeconds: string;
        date: string;
        time: string;
        dateTime: string;
        dateTimeSeconds: string;
        dateMonth: string;
        dateYear: string;
        fullDate: string;
        fullTime: string;
        fullDateTime: string;
        fullDateMonth: string;
        fullDateYear: string;
        localeDate: string;
        localeDateTime: string;
        localeTime: string;
        timezoneDate: string;
        timezoneDateTime: string;
        timezoneDateTimeSeconds: string;
        timezoneTime: string;
        timezoneDateMonth: string;
        timezoneDateYear: string;
        locale: string;
        shortLocale: string;
        fullLocale: string;
    };
    private _mode;
    private _format;
    private _tooltipFormat;
    private _clipFormat;
    private _clickable;
    private _type;
    constructor(clipboard: Clipboard, notificationService: NotificationService);
    ngOnInit(): void;
    ngOnChanges(): void;
    click(): void;
    onClick(item: any): void;
    private update;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxTimeDisplayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxTimeDisplayComponent, "ngx-time", never, { "datetime": { "alias": "datetime"; "required": false; }; "precision": { "alias": "precision"; "required": false; }; "timezone": { "alias": "timezone"; "required": false; }; "defaultInputTimeZone": { "alias": "defaultInputTimeZone"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "type": { "alias": "type"; "required": false; }; "format": { "alias": "format"; "required": false; }; "tooltipFormat": { "alias": "tooltipFormat"; "required": false; }; "clipFormat": { "alias": "clipFormat"; "required": false; }; "timezones": { "alias": "timezones"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipCssClass": { "alias": "tooltipCssClass"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "defaultCopyKey": { "alias": "defaultCopyKey"; "required": false; }; "invalidDateMessage": { "alias": "invalidDateMessage"; "required": false; }; "clickable": { "alias": "clickable"; "required": false; }; }, {}, never, never, false, never>;
}

declare class TimeDisplayModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TimeDisplayModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TimeDisplayModule, [typeof NgxTimeDisplayComponent], [typeof i2.CommonModule, typeof i4$1.MomentModule, typeof TimeZoneModule, typeof TooltipModule, typeof IconModule, typeof i7.ClipboardModule], [typeof NgxTimeDisplayComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TimeDisplayModule>;
}

declare class DialogDrawerContentComponent {
    drawerTitle: string;
    dismissBtnText: string;
    dismiss: EventEmitter<any>;
    hostClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDrawerContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DialogDrawerContentComponent, "ngx-dialog-drawer-content", never, { "drawerTitle": { "alias": "drawerTitle"; "required": false; }; "dismissBtnText": { "alias": "dismissBtnText"; "required": false; }; }, { "dismiss": "dismiss"; }, never, ["*"], false, never>;
}

declare enum DrawerDirection {
    Left = "left",
    Bottom = "bottom"
}

declare enum DrawerPosition {
    fixed = "fixed",
    absolute = "absolute"
}

declare class DrawerComponent implements OnInit, OnDestroy {
    private readonly elementRef;
    cssClass: string;
    direction: DrawerDirection;
    template: TemplateRef<any>;
    context: any;
    isRoot: boolean;
    get size(): number;
    set size(val: number);
    get zIndex(): number;
    set zIndex(val: number);
    get closeOnOutsideClick(): boolean;
    set closeOnOutsideClick(val: boolean);
    close: EventEmitter<boolean>;
    get cssClasses(): string;
    widthSize: string | number;
    heightSize: string | number;
    position: DrawerPosition;
    private get isLeft();
    private get isBottom();
    private _size;
    private _zIndex;
    private _closeOnOutsideClick;
    constructor(elementRef: ElementRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    setDimensions(size: number): void;
    onEscapeKey(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DrawerComponent, "ngx-drawer", ["ngxDrawer"], { "cssClass": { "alias": "cssClass"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "template": { "alias": "template"; "required": false; }; "context": { "alias": "context"; "required": false; }; "isRoot": { "alias": "isRoot"; "required": false; }; "size": { "alias": "size"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; }, { "close": "close"; }, never, never, false, never>;
}

declare class DrawerContainerDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DrawerContainerDirective, "[drawerContainer]", ["drawerContainer"], {}, {}, never, never, false, never>;
}

declare class DrawerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DrawerModule, [typeof DrawerComponent, typeof DrawerContainerDirective, typeof DialogDrawerContentComponent], [typeof i2.CommonModule, typeof OverlayModule], [typeof DrawerComponent, typeof DrawerContainerDirective, typeof DialogDrawerContentComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DrawerModule>;
}

interface DrawerOptions {
    readonly cssClass?: string;
    readonly direction?: DrawerDirection;
    readonly template?: TemplateRef<any>;
    readonly context?: any;
    readonly size?: number;
    readonly zIndex?: number;
    readonly closeOnOutsideClick?: boolean;
    readonly isRoot?: boolean;
    readonly inputs?: {
        cssClass?: string;
        direction?: DrawerDirection;
        template?: TemplateRef<any>;
        context?: any;
        size?: number;
        zIndex?: number;
        closeOnOutsideClick?: boolean;
        isRoot?: boolean;
    };
    readonly parentContainer?: any;
}

declare class DrawerService extends InjectionRegistryService<DrawerComponent> {
    readonly injectionService: InjectionService;
    private readonly overlayService;
    private readonly rendererFactory;
    type: any;
    readonly defaults: DrawerOptions;
    readonly renderer: Renderer2;
    private zIndex;
    private size;
    private parentListenerFunc;
    constructor(injectionService: InjectionService, overlayService: OverlayService, rendererFactory: RendererFactory2);
    create(options: DrawerOptions): ComponentRef<DrawerComponent>;
    destroy(component: ComponentRef<DrawerComponent>): void;
    assignDefaults(options: DrawerOptions): any;
    createSubscriptions(component: ComponentRef<DrawerComponent>, isRoot?: boolean, parentContainer?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DrawerService>;
}

declare class DropdownMenuDirective extends InViewportDirective {
    readonly _platformIdentifier: any;
    readonly _elementReference: ElementRef;
    readonly _insideViewport: InViewportService;
    readonly element: HTMLElement;
    constructor(_platformIdentifier: any, _elementReference: ElementRef, _insideViewport: InViewportService);
    getCallbackFn(): EventEmitter<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownMenuDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownMenuDirective, "ngx-dropdown-menu", ["ngxDropdownMenu"], {}, {}, never, never, false, never>;
}

declare const enum DropdownShowTypes {
    Click = "click",
    Contextmenu = "contextmenu",
    Dblclick = "dblclick"
}

declare class DropdownToggleDirective {
    private readonly el;
    showEvent: DropdownShowTypes;
    get disabled(): boolean;
    set disabled(disabled: boolean);
    toggle: EventEmitter<Event>;
    readonly element: HTMLElement;
    private _disabled;
    constructor(el: ElementRef<HTMLElement>);
    onClick(event: Event): void;
    onContextmenu(event: Event): void;
    onDblclick(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DropdownToggleDirective, "ngx-dropdown-toggle", ["ngxDropdownToggle"], { "showEvent": { "alias": "showEvent"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "toggle": "toggle"; }, never, never, false, never>;
}

declare class DropdownComponent implements AfterContentInit, OnDestroy {
    private readonly renderer;
    private readonly cd;
    destroy$: Subject<void>;
    private _positionAdjusted;
    get positionAdjusted(): boolean;
    get open(): boolean;
    set open(open: boolean);
    get showCaret(): boolean;
    set showCaret(showCaret: boolean);
    get closeOnClick(): boolean;
    set closeOnClick(closeOnClick: boolean);
    get closeOnOutsideClick(): boolean;
    set closeOnOutsideClick(closeOnOutsideClick: boolean);
    get closeOnMouseLeave(): boolean;
    set closeOnMouseLeave(val: boolean);
    forceDownwardOpening: boolean;
    readonly dropdownToggle: DropdownToggleDirective;
    readonly dropdownMenu: DropdownMenuDirective;
    private _documentListener?;
    private _open;
    private _showCaret;
    private _closeOnClick;
    private _closeOnOutsideClick;
    private _closeOnMouseLeave;
    private _leaveTimeout;
    constructor(renderer: Renderer2, cd: ChangeDetectorRef);
    ngAfterContentInit(): void;
    adjustMenuDirection(event: {
        [InViewportMetadata]: {
            entry: IntersectionObserverEntry;
        };
        target: HTMLElement;
        visible: boolean;
    }): void;
    isIntersectingBottom(entry: IntersectionObserverEntry): boolean;
    ngOnDestroy(): void;
    onDocumentClick(e: Event): void;
    onToggleClick(_: Event): void;
    onMouseLeave(): void;
    onMouseEnter(): void;
    /**
     * @function close
     *
     * Programmatically closes the dropdown menu. This method provides the same behavior as clicking off of the dropdown menu.
     *
     * @returns void
     */
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropdownComponent, "ngx-dropdown", ["ngxDropdown"], { "open": { "alias": "open"; "required": false; }; "showCaret": { "alias": "showCaret"; "required": false; }; "closeOnClick": { "alias": "closeOnClick"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "closeOnMouseLeave": { "alias": "closeOnMouseLeave"; "required": false; }; "forceDownwardOpening": { "alias": "forceDownwardOpening"; "required": false; }; }, {}, ["dropdownToggle", "dropdownMenu"], ["*"], false, never>;
}

declare class DropdownModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DropdownModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DropdownModule, [typeof DropdownComponent, typeof DropdownToggleDirective, typeof DropdownMenuDirective], [typeof i2.CommonModule, typeof i5$1.InViewportModule], [typeof DropdownComponent, typeof DropdownToggleDirective, typeof DropdownMenuDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DropdownModule>;
}

declare enum DropzoneSize {
    Small = "small",
    Large = "large"
}
declare class DropzoneComponent implements OnInit {
    id: string;
    acceptedFileFormats: string[];
    uploader: FileUploader;
    options: FileUploaderOptions;
    size: DropzoneSize;
    get multiple(): boolean;
    set multiple(multiple: boolean);
    afterAddingFile: EventEmitter<{
        fileItem: FileItem;
    }>;
    beforeUploadItem: EventEmitter<{
        fileItem: FileItem;
    }>;
    successItem: EventEmitter<{
        item: any;
        response: string;
        status: number;
        headers: any;
    }>;
    errorItem: EventEmitter<{
        response: string;
        status: number;
        headers: any;
    }>;
    progressAll: EventEmitter<{
        progress: number;
    }>;
    acceptedFileFormatsTextDisplay: string;
    DropzoneSize: typeof DropzoneSize;
    private _multiple;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DropzoneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DropzoneComponent, "ngx-dropzone", never, { "id": { "alias": "id"; "required": false; }; "acceptedFileFormats": { "alias": "acceptedFileFormats"; "required": false; }; "uploader": { "alias": "uploader"; "required": false; }; "options": { "alias": "options"; "required": false; }; "size": { "alias": "size"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; }, { "afterAddingFile": "afterAddingFile"; "beforeUploadItem": "beforeUploadItem"; "successItem": "successItem"; "errorItem": "errorItem"; "progressAll": "progressAll"; }, never, never, false, never>;
}

declare class DropzoneModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DropzoneModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DropzoneModule, [typeof DropzoneComponent], [typeof i2.CommonModule, typeof ButtonModule, typeof IconModule, typeof TooltipModule], [typeof DropzoneComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DropzoneModule>;
}

interface SelectDropdownOption {
    readonly name: string;
    readonly value: any;
    readonly disabled?: boolean;
    readonly hidden?: boolean;
    readonly inputTemplate?: TemplateRef<any>;
    readonly optionTemplate?: TemplateRef<any>;
}

declare class SelectDropdownComponent implements AfterViewInit {
    private readonly elementRef;
    private readonly cdr;
    selected: any[];
    identifier: any;
    filterPlaceholder: string;
    filterEmptyPlaceholder: string;
    emptyPlaceholder: string;
    allowAdditionsText: string | TemplateRef<any>;
    tagging: boolean;
    allowAdditions: boolean;
    filterable: boolean;
    filterCaseSensitive: boolean;
    showSelectAll: boolean;
    multiple: boolean;
    get focusIndex(): number;
    set focusIndex(val: number);
    get filterQuery(): string;
    set filterQuery(val: string);
    get groupBy(): string;
    set groupBy(val: string);
    groupByTemplate: TemplateRef<unknown>;
    get options(): SelectDropdownOption[];
    set options(val: SelectDropdownOption[]);
    keyup: EventEmitter<{
        event: KeyboardEvent;
        value?: string;
    }>;
    selection: EventEmitter<SelectDropdownOption>;
    selectAll: EventEmitter<void>;
    deselection: EventEmitter<SelectDropdownOption>;
    keyboardSelection: EventEmitter<SelectDropdownOption>;
    keyboardDeselection: EventEmitter<SelectDropdownOption>;
    close: EventEmitter<boolean>;
    clearQueryFilter: EventEmitter<void>;
    readonly filterInput?: ElementRef<HTMLInputElement>;
    readonly inViewport: InViewportDirective;
    get element(): any;
    get isNotTemplate(): boolean;
    get hasAvailableOptions(): boolean;
    groups: any[];
    filterQueryIsInOptions: boolean;
    private _options;
    private _groupBy;
    private _filterQuery;
    private _focusIndex;
    constructor(elementRef: ElementRef, cdr: ChangeDetectorRef);
    ngAfterViewInit(): void;
    isSelected(option: SelectDropdownOption): boolean;
    updateFilterQueryIsInOptions(): void;
    clearFilter(filterInput: HTMLInputElement): void;
    onInputKeyUp(event: KeyboardEvent): void;
    onOptionClick(option: SelectDropdownOption): void;
    onCheckboxClick(event: Event, option: SelectDropdownOption): void;
    onOptionKeyDown(event: KeyboardEvent, option?: SelectDropdownOption): void;
    focusNext(): void;
    focusPrev(): void;
    onAddClicked(event: Event, value: any): void;
    onShiftEnterKeyDown(event: any): void;
    onTabKeyDown(event: any): void;
    focusOn(index: number): void;
    private focusElement;
    private calculateGroups;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectDropdownComponent, "ngx-select-dropdown", ["ngxSelectDropdown"], { "selected": { "alias": "selected"; "required": false; }; "identifier": { "alias": "identifier"; "required": false; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; }; "filterEmptyPlaceholder": { "alias": "filterEmptyPlaceholder"; "required": false; }; "emptyPlaceholder": { "alias": "emptyPlaceholder"; "required": false; }; "allowAdditionsText": { "alias": "allowAdditionsText"; "required": false; }; "tagging": { "alias": "tagging"; "required": false; }; "allowAdditions": { "alias": "allowAdditions"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "filterCaseSensitive": { "alias": "filterCaseSensitive"; "required": false; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "focusIndex": { "alias": "focusIndex"; "required": false; }; "filterQuery": { "alias": "filterQuery"; "required": false; }; "groupBy": { "alias": "groupBy"; "required": false; }; "groupByTemplate": { "alias": "groupByTemplate"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "keyup": "keyup"; "selection": "selection"; "selectAll": "selectAll"; "deselection": "deselection"; "keyboardSelection": "keyboardSelection"; "keyboardDeselection": "keyboardDeselection"; "close": "close"; "clearQueryFilter": "clearQueryFilter"; }, never, never, false, never>;
}

interface TooltipConfig {
    tooltipAlignment: AlignmentTypes;
    tooltipPlacement: PlacementTypes;
    tooltipShowEvent: ShowTypes;
    tooltipShowTimeout: number;
    tooltipTitle: string;
    tooltipContext?: any;
    tooltipCssClass?: string;
    tooltipDisabled?: boolean;
    tooltipTemplate?: TemplateRef<any>;
    tooltipType: StyleTypes;
}
declare const DEFAULT_TOOLTIP_CONFIG: TooltipConfig;

declare class SelectOptionDirective implements SelectDropdownOption, OnChanges {
    name: string;
    value: any;
    tooltipConfig: TooltipConfig;
    disabled: boolean;
    hidden: boolean;
    _optionTemplateInput: TemplateRef<any>;
    _optionTemplateQuery: TemplateRef<any>;
    get optionTemplate(): TemplateRef<any>;
    _inputTemplateInput: TemplateRef<any>;
    _inputTemplateQuery: TemplateRef<any>;
    get inputTemplate(): TemplateRef<any>;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectOptionDirective, "ngx-select-option", ["ngxSelectOption"], { "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "tooltipConfig": { "alias": "tooltipConfig"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "_optionTemplateInput": { "alias": "optionTemplate"; "required": false; }; "_inputTemplateInput": { "alias": "inputTemplate"; "required": false; }; }, {}, ["_optionTemplateQuery", "_inputTemplateQuery"], never, false, never>;
}

declare enum FilterItemPositionTypes {
    Left = "left",
    Right = "right"
}

declare enum FilterType {
    Select = "select",
    Button = "button",
    CustomDropdown = "customDropdown"
}

declare enum FilterIconPositionTypes {
    Left = "left",
    Right = "right"
}

interface FilterCustomDropdownComponentOptions {
    index?: number;
    injector?: Injector;
    ngModuleRef?: any;
    environmentInjector?: EnvironmentInjector | any;
    projectableNodes?: Node[][];
    directives?: any[];
    bindings?: Binding[];
}
interface FilterCustomDropdownConfig {
    type: any;
    options?: FilterCustomDropdownComponentOptions;
}
interface FilterCustomDropdown {
    component: FilterCustomDropdownConfig;
    closeOnClick?: boolean;
    closeOnOutsideClick?: boolean;
    containerClasses?: string[];
    showCaret?: boolean;
}

interface SelectionList {
    /**
     * The unique identifier of the selection list.
     */
    id: string;
    /**
     * The display text of the selection list.
     */
    title: string;
    /**
     * An optional property that determines whether the selection list is currently active. This property controls the visibility of its children.
     */
    active?: boolean;
    /**
     * An optional property containing child selection lists.
     */
    children?: SelectionList[];
    /**
     * An optional property that sets the display text for the deselect all option.
     */
    deselectAllText?: string;
    /**
     * An optional property that determines whether the selection list is disabled for selection.
     */
    disabled?: boolean;
    /**
     * An optional property that sets the label text displayed at the top of the selection list.
     */
    label?: string;
    /**
     * An optional object containing metadata associated with the selection list. This object is emitted when the option is selected.
     */
    model?: Record<string, unknown>;
    /**
     * An optional property that sets the display text for the select all option.
     */
    selectAllText?: string;
}

interface SelectionListOption {
    /**
     * The display name of the option.
     */
    name: string;
    /**
     * The unique identifier of the option. This should correspond to the `id` property of a `SelectionList`.
     */
    value: string;
    /**
     * An optional object containing metadata associated with the option.
     */
    model?: Record<string, unknown>;
}

interface SelectionListNavigationEvent {
    active: boolean;
    listId: string;
    selectionList: SelectionList;
}

declare class MultiDimensionSelectionComponent implements OnChanges, AfterViewInit {
    detached: i0.InputSignal<boolean>;
    emptyPlaceholder: i0.InputSignal<string>;
    filterable: i0.InputSignal<boolean>;
    filterEmptyPlaceholder: i0.InputSignal<string>;
    multiple: i0.InputSignal<boolean>;
    selected: i0.InputSignal<string[]>;
    selectionList: i0.InputSignal<SelectionList>;
    onClose: i0.OutputEmitterRef<void>;
    onSelectedChange: i0.OutputEmitterRef<SelectionListOption[]>;
    parentMap: Map<string, string>;
    searchTerm: string;
    selectedSet: Set<string>;
    selectionListModel: SelectionList;
    selectionLists: SelectionList[];
    selectionMap: Map<string, SelectionList>;
    filterInput: i0.Signal<InputComponent>;
    inViewport: i0.Signal<InViewportDirective>;
    onKeydownEscape(): void;
    private readonly cdr;
    private readonly elementRef;
    get element(): any;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    /**
     * @function handleListNavigation
     *
     * @description
     * Handler for when a list option is activated or deactivated.
     *
     * @param {SelectionListNavigationEvent} event - The list navigation event
     */
    handleListNavigation(event: SelectionListNavigationEvent): void;
    /**
     * @function handleSelectedChange
     *
     * @description
     * Handler for when an option is selected or deselected. Emits the updated list of selected options.
     */
    handleSelectedChange(): void;
    /**
     * @function handleSearchTermChange
     *
     * @description
     * Handler for when the search term changes. Filters the selection list based on the search term.
     *
     * @param {string} searchTerm - the user-entered search term
     *
     * @optional
     * @param {boolean} focusInput - whether to focus the search input
     */
    handleSearchTermChange(searchTerm: string, focusInput?: boolean): void;
    /**
     * @function buildParentMap
     *
     * @description
     * Builds the parent map containing the child to parent relationships for the selection list.
     *
     * @param {SelectionList} selectionList - the current selection list being processed
     * @param {Map<string, string>} parentMap - the map to populate
     * @param {SelectionList} parent - the parent selection list of the current selection list
     */
    private buildParentMap;
    /**
     * @function buildSelectionMap
     *
     * @description
     * Builds the selection map containing the ID to `SelectionList` relationships for the selection list.
     *
     * @param {SelectionList} selectionList - the current selection list being processed
     * @param {Map<string, SelectionList>} selectionMap - the map to populate
     */
    private buildSelectionMap;
    /**
     * @function generateSelectionLists
     *
     * @description
     * Generates the selection lists from the current selection model.
     *
     * @returns {Array<SelectionList>} The array of selection lists
     */
    private generateSelectionLists;
    /**
     * @function initSelectionLists
     *
     * @description
     * Initializes all selection list data.
     */
    private initSelectionLists;
    /**
     * @function searchAllDimensions
     *
     * @description
     * Recursively searches all dimensions of the selection list to find matches for the provided `searchTerm`.
     *
     * @param {SelectionList} selectionList - the current selection list being processed
     * @param {string} searchTerm - the lower case, user-entered search term
     *
     * @returns {SelectionList | null} The matching selection list or `null` if no match is found
     */
    private searchAllDimensions;
    /**
     * @function deactivatePath
     *
     * @description
     * Recursively deactivates the active path for the provided `selectionList` and any active children.
     *
     * @param {SelectionList | undefined} selectionList - the list to deactivate
     */
    private deactivatePath;
    /**
     * @function setActivePath
     *
     * @description
     * Recursively sets the active path for the provided `selectionList` and its first child with children.
     *
     * @param {SelectionList} selectionList - the current selection list being processed
     */
    private setActivePath;
    /**
     * @function traverseActivePath
     *
     * @description
     * Recursively traverses the active path of the provided `selectionList` and its children, building the array of selection lists.
     *
     * @param {SelectionList | undefined} selectionList - the current selection list being processed
     * @param {Array<SelectionList>} activeLists - the array to append selection lists to
     *
     * @returns {Array<SelectionList>} The array of selection lists
     */
    private traverseActivePath;
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiDimensionSelectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MultiDimensionSelectionComponent, "ngx-multi-dimension-selection", never, { "detached": { "alias": "detached"; "required": false; "isSignal": true; }; "emptyPlaceholder": { "alias": "emptyPlaceholder"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "filterEmptyPlaceholder": { "alias": "filterEmptyPlaceholder"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectionList": { "alias": "selectionList"; "required": false; "isSignal": true; }; }, { "onClose": "onClose"; "onSelectedChange": "onSelectedChange"; }, never, never, false, never>;
}

declare class FilterComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {
    private readonly _element;
    private readonly _renderer;
    private readonly _cdr;
    id: string;
    name: string;
    label: string;
    placeholder: string;
    emptyPlaceholder: string;
    filterEmptyPlaceholder: string;
    filterPlaceholder: string;
    groupBy: string;
    options: SelectDropdownOption[];
    identifier: string;
    appearance: Appearance;
    itemsPosition: FilterItemPositionTypes;
    ngxIconPosition: FilterIconPositionTypes;
    ngxIconClass: string;
    type: FilterType;
    set filterCount(value: number);
    customDropdownConfig: FilterCustomDropdown;
    showTooltip: boolean;
    tooltipTemplate: TemplateRef<unknown> | null;
    tooltipPosition: PlacementTypes;
    selectionList: SelectionList;
    forceDownwardOpening: boolean;
    autoSelectAll: boolean;
    get autosizeMinWidth(): number | string;
    set autosizeMinWidth(autosizeMinWidth: number | string);
    autofocus: boolean;
    autosize: boolean;
    disableDropdown: boolean;
    closeOnSelect: boolean;
    closeOnBodyClick: boolean;
    filterable: boolean;
    filterCaseSensitive: boolean;
    showSelectAll: boolean;
    multiple: boolean;
    disabled: boolean;
    showCount: boolean;
    multiDimension: boolean;
    change: EventEmitter<any[]>;
    keyup: EventEmitter<{
        event: KeyboardEvent;
        value?: string;
    }>;
    toggle: EventEmitter<boolean>;
    clearQueryFilter: EventEmitter<void>;
    clicked: EventEmitter<{
        event: KeyboardEvent;
        isIconClicked: boolean;
    }>;
    dynamicComponentRef: ComponentRef<any>;
    readonly selectDropdown: SelectDropdownComponent;
    readonly dropdownComponent: DropdownComponent;
    dynamicContainer: ViewContainerRef;
    readonly multiDimensionDropdown: MultiDimensionSelectionComponent;
    readonly FilterItemPositionTypes: typeof FilterItemPositionTypes;
    readonly FilterType: typeof FilterType;
    readonly FilterIconPositionTypes: typeof FilterIconPositionTypes;
    /**
     * Custom Template for groupBy
     * Only works with groupBy on
     *
     * TemplateContext:
     * - groupName: the name of the group (`option.value[this.groupBy]` is the value)
     * - index, first, last, odd, even (ngFor properties)
     */
    groupByTemplate: TemplateRef<unknown>;
    get optionTemplates(): QueryList<SelectOptionDirective>;
    set optionTemplates(val: QueryList<SelectOptionDirective>);
    get isSingleSelect(): boolean;
    get hasSelections(): boolean;
    get hasPlaceholder(): boolean;
    get selection(): string;
    get multiDimensionDropdownValue(): Array<string>;
    get value(): any[];
    set value(val: any[]);
    get dropdownVisible(): boolean;
    get multiDimensionDropdownVisible(): boolean;
    get filterCount(): number;
    get dropdownActive(): boolean;
    get multiDimensionDropdownActive(): boolean;
    toggleListener?: () => void;
    filterQuery: string;
    focusIndex: number;
    _dropdownActive: boolean;
    _multiDimensionDropdownActive: boolean;
    touched: boolean;
    private _optionTemplates;
    private _value;
    private _selection;
    private _autosizeMinWidth;
    private _filterCount;
    constructor(_element: ElementRef, _renderer: Renderer2, _cdr: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    onDropdownSelection(selection: SelectDropdownOption, shouldClose?: boolean): void;
    onDropdownDeselection(selection: SelectDropdownOption, shouldClose?: boolean): void;
    onMultiDimensionDropdownChange(selection: Array<SelectionListOption>): void;
    private afterSelect;
    onFocus(): void;
    onFocusLast(): void;
    focusOn(index: number): void;
    onClear(): void;
    onBodyClick(event: Event): void;
    onClose(): void;
    onToggle(event: any): void;
    toggleDropdown(state: boolean): void;
    toggleMultiDimensionDropdown(state: boolean): void;
    get caretVisible(): boolean;
    get clearVisible(): boolean;
    get hasControls(): boolean;
    get hasFilters(): boolean;
    onKeyUp({ event, value }: {
        event: KeyboardEvent;
        value?: string;
    }): void;
    onSelectAll(): void;
    onFilterButtonClick(event: any): void;
    onCustomDropdownToggle(): void;
    writeValue(val: any[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    createDynamicComponent(): void;
    private findIndex;
    private adjustMenuDirection;
    private isIntersectingBottom;
    private isIntersectingTop;
    private onChangeCallback;
    private onTouchedCallback;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent, "ngx-filter", ["ngxFilter"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "emptyPlaceholder": { "alias": "emptyPlaceholder"; "required": false; }; "filterEmptyPlaceholder": { "alias": "filterEmptyPlaceholder"; "required": false; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; }; "groupBy": { "alias": "groupBy"; "required": false; }; "options": { "alias": "options"; "required": false; }; "identifier": { "alias": "identifier"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "itemsPosition": { "alias": "itemsPosition"; "required": false; }; "ngxIconPosition": { "alias": "ngxIconPosition"; "required": false; }; "ngxIconClass": { "alias": "ngxIconClass"; "required": false; }; "type": { "alias": "type"; "required": false; }; "filterCount": { "alias": "filterCount"; "required": false; }; "customDropdownConfig": { "alias": "customDropdownConfig"; "required": false; }; "showTooltip": { "alias": "showTooltip"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "selectionList": { "alias": "selectionList"; "required": false; }; "forceDownwardOpening": { "alias": "forceDownwardOpening"; "required": false; }; "autoSelectAll": { "alias": "autoSelectAll"; "required": false; }; "autosizeMinWidth": { "alias": "autosizeMinWidth"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "autosize": { "alias": "autosize"; "required": false; }; "disableDropdown": { "alias": "disableDropdown"; "required": false; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; }; "closeOnBodyClick": { "alias": "closeOnBodyClick"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "filterCaseSensitive": { "alias": "filterCaseSensitive"; "required": false; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showCount": { "alias": "showCount"; "required": false; }; "multiDimension": { "alias": "multiDimension"; "required": false; }; "groupByTemplate": { "alias": "groupByTemplate"; "required": false; }; }, { "change": "change"; "keyup": "keyup"; "toggle": "toggle"; "clearQueryFilter": "clearQueryFilter"; "clicked": "clicked"; }, ["optionTemplates"], never, false, never>;
}

declare class SelectInputComponent implements AfterViewInit, OnChanges {
    selectId: string;
    placeholder: string;
    identifier: string;
    options: SelectDropdownOption[];
    label: string;
    hint: string;
    selectCaret: string | TemplateRef<any>;
    requiredIndicator: string | boolean;
    tabindex: number;
    withHint: boolean;
    autofocus: boolean;
    allowClear: boolean;
    multiple: boolean;
    tagging: boolean;
    allowAdditions: boolean;
    disableDropdown: boolean;
    disabled: boolean;
    get selected(): any[];
    set selected(val: any[]);
    toggle: EventEmitter<void>;
    close: EventEmitter<void>;
    selection: EventEmitter<any[]>;
    activate: EventEmitter<void>;
    activateLast: EventEmitter<void>;
    keyup: EventEmitter<{
        event: KeyboardEvent;
        value?: string;
    }>;
    readonly inputContainer?: ElementRef<HTMLElement>;
    readonly inputElement?: ElementRef<HTMLInputElement>;
    get caretVisible(): boolean;
    get clearVisible(): boolean;
    get hasControls(): boolean;
    get isNotTemplate(): boolean;
    selectedOptions: SelectDropdownOption[];
    private _selected;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    onInputKeyDown(event: KeyboardEvent): void;
    onInputKeyUp(event: KeyboardEvent): void;
    clearInput(): void;
    onGlobalKeyUp(event: KeyboardEvent): void;
    onKeyDown(event: KeyboardEvent): void;
    onClick(): void;
    onFocus(): void;
    onToggle(_ev?: PointerEvent): void;
    onClear(ev?: PointerEvent): void;
    onOptionRemove(event: Event, option: SelectDropdownOption): void;
    onClearTaggingInput(ev?: PointerEvent): void;
    focus(): void;
    private calcSelectedOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectInputComponent, "ngx-select-input", ["ngxSelectInput"], { "selectId": { "alias": "selectId"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "identifier": { "alias": "identifier"; "required": false; }; "options": { "alias": "options"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "selectCaret": { "alias": "selectCaret"; "required": false; }; "requiredIndicator": { "alias": "requiredIndicator"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "withHint": { "alias": "withHint"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "allowClear": { "alias": "allowClear"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "tagging": { "alias": "tagging"; "required": false; }; "allowAdditions": { "alias": "allowAdditions"; "required": false; }; "disableDropdown": { "alias": "disableDropdown"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "toggle": "toggle"; "close": "close"; "selection": "selection"; "activate": "activate"; "activateLast": "activateLast"; "keyup": "keyup"; }, never, ["ngx-input-hint"], false, never>;
}

declare const _InputMixinBase: any;
declare class SelectComponent extends _InputMixinBase implements ControlValueAccessor, OnDestroy {
    private readonly _element;
    private readonly _renderer;
    private readonly _cdr;
    id: string;
    name: string;
    label: string;
    hint: string;
    placeholder: string;
    emptyPlaceholder: string;
    filterEmptyPlaceholder: string;
    filterPlaceholder: string;
    forceDownwardOpening: boolean;
    allowAdditionsText: string;
    groupBy: string;
    selectCaret: string;
    requiredIndicator: string | boolean;
    withHint: boolean;
    withMargin: boolean;
    set options(options: SelectDropdownOption[]);
    get options(): SelectDropdownOption[];
    identifier: string;
    appearance: Appearance;
    minSelections?: number;
    maxSelections?: number;
    get autosizeMinWidth(): number | string;
    set autosizeMinWidth(autosizeMinWidth: number | string);
    autofocus: boolean;
    autosize: boolean;
    allowClear: boolean;
    allowAdditions: boolean;
    disableDropdown: boolean;
    closeOnSelect: boolean;
    closeOnBodyClick: boolean;
    filterable: boolean;
    required: boolean;
    filterCaseSensitive: boolean;
    tagging: boolean;
    multiple: boolean;
    disabled: boolean;
    change: EventEmitter<any[]>;
    keyup: EventEmitter<{
        event: KeyboardEvent;
        value?: string;
    }>;
    toggle: EventEmitter<boolean>;
    clearQueryFilter: EventEmitter<void>;
    readonly inputComponent: SelectInputComponent;
    readonly selectDropdown: SelectDropdownComponent;
    /**
     * Custom Template for groupBy
     * Only works with groupBy on
     *
     * TemplateContext:
     * - groupName: the name of the group (`option.value[this.groupBy]` is the value)
     * - index, first, last, odd, even (ngFor properties)
     */
    groupByTemplate: TemplateRef<unknown>;
    get optionTemplates(): QueryList<SelectOptionDirective>;
    set optionTemplates(val: QueryList<SelectOptionDirective>);
    get invalid(): boolean;
    get requiredIndicatorView(): string;
    get isSingleSelect(): boolean;
    get hasSelections(): boolean;
    get hasPlaceholder(): boolean;
    get value(): any[];
    set value(val: any[]);
    get dropdownVisible(): boolean;
    toggleListener?: () => void;
    filterQuery: string;
    focusIndex: number;
    dropdownActive: boolean;
    touched: boolean;
    private _optionTemplates;
    private _value;
    private _autosizeMinWidth;
    private _options;
    private _boundByOptionsInput;
    constructor(_element: ElementRef, _renderer: Renderer2, _cdr: ChangeDetectorRef);
    ngOnDestroy(): void;
    onDropdownSelection(selection: SelectDropdownOption, shouldClose?: boolean): void;
    onDropdownDeselection(selection: SelectDropdownOption, shouldClose?: boolean): void;
    private afterSelect;
    onInputSelection(selections: any[]): void;
    onFocus(): void;
    onFocusLast(): void;
    focusOn(index: number): void;
    onClear(): void;
    onBodyClick(event: Event): void;
    onClose(keepFocus?: boolean): void;
    onToggle(): void;
    toggleDropdown(state: boolean): void;
    onKeyUp({ event, value }: {
        event: KeyboardEvent;
        value?: string;
    }): void;
    writeValue(val: any[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    private findIndex;
    private adjustMenuDirection;
    private isIntersectingBottom;
    private isIntersectingTop;
    private checkInvalidValue;
    private onChangeCallback;
    private onTouchedCallback;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "ngx-select", ["ngxSelect"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "emptyPlaceholder": { "alias": "emptyPlaceholder"; "required": false; }; "filterEmptyPlaceholder": { "alias": "filterEmptyPlaceholder"; "required": false; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; }; "forceDownwardOpening": { "alias": "forceDownwardOpening"; "required": false; }; "allowAdditionsText": { "alias": "allowAdditionsText"; "required": false; }; "groupBy": { "alias": "groupBy"; "required": false; }; "selectCaret": { "alias": "selectCaret"; "required": false; }; "requiredIndicator": { "alias": "requiredIndicator"; "required": false; }; "withHint": { "alias": "withHint"; "required": false; }; "withMargin": { "alias": "withMargin"; "required": false; }; "options": { "alias": "options"; "required": false; }; "identifier": { "alias": "identifier"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "minSelections": { "alias": "minSelections"; "required": false; }; "maxSelections": { "alias": "maxSelections"; "required": false; }; "autosizeMinWidth": { "alias": "autosizeMinWidth"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "autosize": { "alias": "autosize"; "required": false; }; "allowClear": { "alias": "allowClear"; "required": false; }; "allowAdditions": { "alias": "allowAdditions"; "required": false; }; "disableDropdown": { "alias": "disableDropdown"; "required": false; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; }; "closeOnBodyClick": { "alias": "closeOnBodyClick"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "required": { "alias": "required"; "required": false; }; "filterCaseSensitive": { "alias": "filterCaseSensitive"; "required": false; }; "tagging": { "alias": "tagging"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "groupByTemplate": { "alias": "groupByTemplate"; "required": false; }; }, { "change": "change"; "keyup": "keyup"; "toggle": "toggle"; "clearQueryFilter": "clearQueryFilter"; }, ["optionTemplates"], never, false, never>;
}

declare class SelectOptionTemplateDirective {
    readonly template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectOptionTemplateDirective, "[ngx-select-option-template]", ["ngxSelectOptionTemplate"], {}, {}, never, never, false, never>;
}

declare class SelectOptionInputTemplateDirective {
    readonly template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectOptionInputTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SelectOptionInputTemplateDirective, "[ngx-select-option-input-template]", ["ngxSelectOptionInputTemplate"], {}, {}, never, never, false, never>;
}

declare class SelectModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectModule, [typeof SelectComponent, typeof SelectInputComponent, typeof SelectOptionDirective, typeof SelectOptionTemplateDirective, typeof SelectDropdownComponent, typeof SelectOptionInputTemplateDirective], [typeof i2.CommonModule, typeof i5$1.InViewportModule, typeof TooltipModule, typeof CheckboxModule], [typeof SelectComponent, typeof SelectDropdownComponent, typeof SelectInputComponent, typeof SelectOptionDirective, typeof SelectOptionTemplateDirective, typeof SelectOptionInputTemplateDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SelectModule>;
}

interface DateRangeForm {
    startRaw: string;
    endRaw: string;
    startDate: Date | null;
    endDate: Date | null;
}
interface TooltipDateItem {
    key: string;
    value: {
        clip: string;
        display: string;
    };
}

/**
 * DateRangePickerComponent
 * ------------------------
 * A fully configurable, Angular component to pick and emit a date range.
 *
 *  Usage:
 * <ngx-date-range-picker
 *   [presets]="customPresets"                     // Optional: override default presets
 *   [parseFn]="customParseFunction"               // Optional: function to parse expressions like now-7d
 *   [showTooltip]="true"                          // Optional: toggle tooltip
 *   [placeholders]="{ start: 'Start...', end: 'End...' }" // Optional: custom input placeholders
 *   (apply)="handleApply($event)"
 *   (cancel)="handleCancel()"
 * ></ngx-date-range-picker>
 *
 * This component is designed for reusability and composability in libraries and apps.
 */

declare class DateRangePickerComponent implements OnInit, OnChanges {
    private cdr;
    private readonly clipboard;
    private readonly notificationService;
    presets: {
        label: string;
        range: () => [Date | null, Date | null];
        expression?: {
            start: string;
            end: string;
        };
    }[];
    parseFn: (expr: string, context?: 'start' | 'end') => Date;
    showTooltip: boolean;
    placeholders: {
        start: string;
        end: string;
    };
    timezones: Record<string, string>;
    selectedRange: {
        start: string;
        end: string;
    } | null;
    apply: EventEmitter<{
        start: Date;
        end: Date;
        label: string;
        tooltipValues: {
            startTime: Record<string, {
                key: string;
                clip: string;
                display: string;
            }>;
            endTime: Record<string, {
                key: string;
                clip: string;
                display: string;
            }>;
        };
        startExpression: string;
        endExpression: string;
    }>;
    cancel: EventEmitter<string>;
    wrapperRef: DropdownComponent;
    private readonly dateFormat;
    lastConfirmedRange: {
        startDate: Date;
        endDate: Date;
        startRaw: string;
        endRaw: string;
    };
    form: DateRangeForm;
    showPicker: boolean;
    validationError: string | null;
    selectedPreset: any;
    selectedLabel: string;
    pickerStyles: {
        [key: string]: string;
    };
    rangeModel: {
        startDate: Date;
        endDate: Date;
    };
    rangeModelRightCalendar: {
        startDate: Date;
        endDate: Date;
    };
    leftViewDate: Date;
    rightViewDate: Date;
    leftMinDate: any;
    leftMaxDate: Date;
    nextMonth: Date;
    rightMinDate: Date;
    rightMaxDate: any;
    timeValueStart: Record<string, {
        key: string;
        clip: string;
        display: string;
    }>;
    timeValueEnd: Record<string, {
        key: string;
        clip: string;
        display: string;
    }>;
    get isApplyDisabled(): boolean;
    constructor(cdr: ChangeDetectorRef, clipboard: Clipboard, notificationService: NotificationService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private initializeFromSelectedRange;
    onRangeSelect(range: {
        startDate: Date;
        endDate: Date;
    }): void;
    updateCalendarConstraints(selectedDate: Date): void;
    onCustomInputChange(): void;
    updateSelectedLabel(): void;
    private createMoment;
    updateSelectedPresetByValue(): void;
    selectPreset(preset: {
        label: string;
        range: () => [Date | null, Date | null];
        expression?: {
            start: string;
            end: string;
        };
    }): void;
    isEqual(a: Date, b: Date): boolean;
    onApply(): void;
    onCancel(): void;
    resetForm(): void;
    openSearchStringDocPage(): void;
    setTooltipDate(start: Date, end: Date): void;
    onClick(item: TooltipDateItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangePickerComponent, "ngx-date-range-picker", never, { "presets": { "alias": "presets"; "required": false; }; "parseFn": { "alias": "parseFn"; "required": false; }; "showTooltip": { "alias": "showTooltip"; "required": false; }; "placeholders": { "alias": "placeholders"; "required": false; }; "timezones": { "alias": "timezones"; "required": false; }; "selectedRange": { "alias": "selectedRange"; "required": false; }; }, { "apply": "apply"; "cancel": "cancel"; }, never, never, false, never>;
}

declare class DateRangePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DateRangePickerModule, [typeof DateRangePickerComponent], [typeof InputModule, typeof DropdownModule, typeof ButtonModule, typeof IconModule, typeof TooltipModule, typeof i2.CommonModule, typeof i3.FormsModule, typeof CalendarModule], [typeof DateRangePickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DateRangePickerModule>;
}

declare class SelectionListComponent {
    multiple: i0.InputSignal<boolean>;
    parentMap: i0.InputSignal<Map<string, string>>;
    selected: i0.InputSignal<Set<string>>;
    selectionList: i0.InputSignal<SelectionList>;
    selectionLists: i0.InputSignal<SelectionList[]>;
    selectionMap: i0.InputSignal<Map<string, SelectionList>>;
    onListNavigation: i0.OutputEmitterRef<SelectionListNavigationEvent>;
    onSelectedChange: i0.OutputEmitterRef<void>;
    get selectDeselectText(): string;
    /**
     * @function handleListNavigation
     *
     * @description
     * Handler for when a list option is activated or deactivated.
     *
     * @param {SelectionList} selectionList - the activated or deactivated list option
     * @param {boolean} active - whether the list option is active
     */
    handleListNavigation(selectionList: SelectionList, active: boolean): void;
    /**
     * @function handleSelectionChange
     *
     * @description
     * Handler for when a list option is selected or deselected.
     *
     * @param {Event} event - the change event from the checkbox input
     * @param {SelectionList} selectionList - the selected list option
     */
    handleSelectionChange(event: Event, selectionList: SelectionList): void;
    /**
     * @function handleSelectDeselectAll
     *
     * @description
     * Handler for when a user clicks the select/deselect all button.
     */
    handleSelectDeselectAll(): void;
    /**
     * @function handleSelectOption
     *
     * @description
     * Handler for when a user clicks or presses the enter key on a list option.
     *
     * @param {SelectionList} selectionList - the selected list option
     */
    handleSelectOption(selectionList: SelectionList): void;
    /**
     * @function deselectAncestorsWithoutSelectedChildren
     *
     * @description
     * Deselects all ancestors if they have no selected children.
     *
     * @param {string} id - the ID of the list option that was selected/deselected
     */
    private deselectAncestorsWithoutSelectedChildren;
    /**
     * @function selectAllAncestors
     *
     * @description
     * Selects all ancestors of the selected list option.
     *
     * @param {string} id - the ID of the selected list option
     */
    private selectAllAncestors;
    /**
     * @function selectDeselectAllChildren
     *
     * @description
     * Recursively selects or deselects all items in the provided `children` array.
     *
     * @param {boolean} selected - whether to select all items
     * @param {SelectionList[]} children - the array of child items to select or deselect
     */
    private selectDeselectAllChildren;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionListComponent, "ngx-selection-list", never, { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "parentMap": { "alias": "parentMap"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectionList": { "alias": "selectionList"; "required": false; "isSignal": true; }; "selectionLists": { "alias": "selectionLists"; "required": false; "isSignal": true; }; "selectionMap": { "alias": "selectionMap"; "required": false; "isSignal": true; }; }, { "onListNavigation": "onListNavigation"; "onSelectedChange": "onSelectedChange"; }, never, never, false, never>;
}

declare class SelectionListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionListModule, [typeof SelectionListComponent], [typeof CheckboxModule, typeof i2.CommonModule, typeof i3.FormsModule, typeof i5$2.ScrollingModule, typeof TooltipModule], [typeof SelectionListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SelectionListModule>;
}

declare class MultiDimensionSelectionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MultiDimensionSelectionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MultiDimensionSelectionModule, [typeof MultiDimensionSelectionComponent], [typeof i3.FormsModule, typeof InputModule, typeof i5$1.InViewportModule, typeof SelectionListModule], [typeof MultiDimensionSelectionComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MultiDimensionSelectionModule>;
}

declare class FiltersModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FiltersModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FiltersModule, [typeof FilterComponent], [typeof i2.CommonModule, typeof i5$1.InViewportModule, typeof TooltipModule, typeof SelectModule, typeof DropdownModule, typeof DateRangePickerModule, typeof MultiDimensionSelectionModule], [typeof FilterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FiltersModule>;
}

declare class HotkeysComponent implements OnInit, OnDestroy {
    private readonly _hotkeysService;
    readonly hotkeys$: BehaviorSubject<Hotkey[]>;
    visible: boolean;
    private readonly _destroy;
    constructor(_hotkeysService: HotkeysService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    updateHotkeys(hotkeys: {
        [combo: string]: Hotkey[];
    }): void;
    show(): void;
    hide(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HotkeysComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HotkeysComponent, "ngx-hotkeys", ["ngxHotkeys"], {}, {}, never, never, false, never>;
}

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

declare enum HotkeyStatus {
    Active = "active",
    Suspended = "suspended",
    Disabled = "disabled"
}

declare class SchemaValidatorService {
    ajv: Ajv;
    constructor();
    /**
     * Validates schemas of a specified type
     */
    validate(schema: any, model: any): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SchemaValidatorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SchemaValidatorService>;
}

declare const requiredIndicatorIcon = "\n  <svg width=\"11\" height=\"11\" viewBox=\"0 0 11 11\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n    <path d=\"M3.38411 10L2.19205 9.10616L3.89073 6.2089L1 4.97603L1.44702 3.55822L4.48676 4.32877L4.75497 1H6.21523L6.48344 4.29795L9.55298 3.55822L10 4.97603L7.10927 6.2089L8.77815 9.10616L7.61589 10L5.5 7.34931L3.38411 10Z\" fill=\"#72819F\" stroke=\"#72819F\" stroke-width=\"0.5\"/>\n  </svg>";
interface JSONEditorTemplateProperty {
    key?: string;
    keyFieldType?: JSONSchema7TypeName;
    keyFieldFormat?: string;
    enum?: JSONSchema7Type[] | undefined;
    isRequired?: boolean;
    value?: any | undefined;
}
interface JSONEditorSchema extends JSONSchema7 {
    $meta?: any;
    properties?: {
        [key: string]: JSONEditorSchema;
    };
    patternProperties?: {
        [key: string]: JSONEditorSchema;
    };
    items?: JSONEditorSchema;
    nameEditable?: boolean;
    propertyName?: string;
    currentType?: JSONSchema7TypeName | JSONSchema7TypeName[];
    id?: number;
}
interface PropertyIndex extends JSONEditorSchema {
    [id: number]: JSONEditorSchema;
}
interface JsonSchemaDataType {
    name: string;
    defaultValue: () => any;
    schema: {
        type: string;
        format?: string;
    };
    icon: string;
    matchType: (value: string) => boolean;
}
declare const propTypes: string[];
declare const jsonSchemaDataTypes: JsonSchemaDataType[];
declare const jsonSchemaDataFormats: JsonSchemaDataType[];
declare const dataTypeMap: Record<string, any>;
declare function createValueForSchema(schema: JSONEditorSchema): any;
/**
 * Infers the schema type of the value
 *
 * @param value the value to infer the schema for
 * @param overrides an object with overridden inference functions for various schema types
 * @param allowedTypes the allowed schema types to consider
 */
declare function inferType(value: any, overrides?: any, allowedTypes?: string[]): any;
/**
 * Returns the icon for the schema
 */
declare function getIcon(schema: JSONEditorSchema): string;
/**
 * Returns a string for the schema.$meta.currentType property in the following format:
 * string, string=code, object, etc.
 *
 * @param schema
 */
declare function getCurrentType(schema: JSONEditorSchema): string;

declare class JsonEditor implements OnChanges {
    protected schemaValidatorService: SchemaValidatorService;
    protected cdr: ChangeDetectorRef;
    model: any;
    schema: JSONEditorSchema;
    label: string;
    typeCheckOverrides?: any;
    schemaValidator?: (schema: any, ...args: any[]) => any[];
    showKnownProperties: boolean;
    modelChange: EventEmitter<any>;
    schemaUpdate: EventEmitter<JSONEditorSchema>;
    errors: any[];
    constructor(schemaValidatorService: SchemaValidatorService, cdr: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Model change callback. Validates the model and emits a change event
     *
     * @param model
     */
    modelChangedCallback(model: any): void;
    /**
     * Validates the model based on the schema
     *
     * @param schema
     * @param model
     */
    validate(schema: any, model: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditor, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<JsonEditor, never, never, { "model": { "alias": "model"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "label": { "alias": "label"; "required": false; }; "typeCheckOverrides": { "alias": "typeCheckOverrides"; "required": false; }; "schemaValidator": { "alias": "schemaValidator"; "required": false; }; "showKnownProperties": { "alias": "showKnownProperties"; "required": false; }; }, { "modelChange": "modelChange"; "schemaUpdate": "schemaUpdate"; }, never, never, true, never>;
}

declare class JsonEditorNode implements OnInit, OnChanges {
    dialogMngr: DialogService;
    schema: JSONEditorSchema;
    model: any;
    required: boolean;
    inline: boolean;
    path: string;
    errors: any[];
    typeCheckOverrides?: any;
    showKnownProperties: boolean;
    modelChange: EventEmitter<any>;
    schemaUpdate: EventEmitter<JSONEditorSchema>;
    codeEditorTpl: TemplateRef<any>;
    requiredCache: any;
    expanded: boolean;
    ownErrors: any[];
    valid: boolean;
    childrenErrors: any[];
    childrenValid: boolean;
    editorDialog: ComponentRef<DialogComponent>;
    editorConfig: {
        lineNumbers: boolean;
        theme: string;
        mode: {
            label: string;
            name: string;
            json: boolean;
        };
    };
    editorModel: string;
    editorVisible: boolean;
    editorModes: any[];
    constructor(dialogMngr: DialogService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Inits the model if it is not defined
     */
    initModel(): void;
    /**
     * Process the errors input to figure out whether it or any of its children are invalid
     */
    processErrors(): void;
    /**
     * Updates the whole model and emits the change event
     *
     * @param value
     */
    updateModel(value: any): void;
    updateDateTimeModel(value: any, format: DateFormatPipe): void;
    /**
     * Expand click event
     */
    onExpandClick(): void;
    /**
     * Opens the code editor dialog
     */
    openCodeEditor(): void;
    /**
     * Closes the code editor dialog
     */
    closeCodeEditor(): void;
    /**
     * Sets the editor mode and refreshes the editor
     */
    selectEditorMode(modeName: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditorNode, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<JsonEditorNode, never, never, { "schema": { "alias": "schema"; "required": false; }; "model": { "alias": "model"; "required": false; }; "required": { "alias": "required"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "path": { "alias": "path"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "typeCheckOverrides": { "alias": "typeCheckOverrides"; "required": false; }; "showKnownProperties": { "alias": "showKnownProperties"; "required": false; }; }, { "modelChange": "modelChange"; "schemaUpdate": "schemaUpdate"; }, never, never, true, never>;
}

declare class JsonEditorNodeComponent extends JsonEditorNode implements OnInit {
    dialogMngr: DialogService;
    private dateFormat;
    model: any;
    schema: JSONEditorSchema;
    typeCheckOverrides?: any;
    errors: any[];
    showKnownProperties: boolean;
    isDuplicated: boolean;
    passwordToggleEnabled: boolean;
    placeholder: string;
    constructor(dialogMngr: DialogService, dateFormat: DateFormatPipe);
    ngOnInit(): void;
    updateDateTime(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditorNodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JsonEditorNodeComponent, "ngx-json-editor-node", never, { "model": { "alias": "model"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "typeCheckOverrides": { "alias": "typeCheckOverrides"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "showKnownProperties": { "alias": "showKnownProperties"; "required": false; }; "isDuplicated": { "alias": "isDuplicated"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class JsonEditorComponent extends JsonEditor {
    protected schemaValidatorService: SchemaValidatorService;
    protected cdr: ChangeDetectorRef;
    model: any;
    schema: JSONEditorSchema;
    typeCheckOverrides?: any;
    passwordToggleEnabled: boolean;
    nodeElms: QueryList<JsonEditorNodeComponent>;
    constructor(schemaValidatorService: SchemaValidatorService, cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JsonEditorComponent, "ngx-json-editor", never, { "model": { "alias": "model"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "typeCheckOverrides": { "alias": "typeCheckOverrides"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; }, {}, ["nodeElms"], never, false, never>;
}

declare class ObjectNode implements OnInit, OnChanges {
    protected cdr: ChangeDetectorRef;
    schema: JSONEditorSchema;
    model: any;
    required: boolean;
    expanded: boolean;
    path: string;
    errors: any[];
    typeCheckOverrides?: any;
    schemaBuilderMode: boolean;
    schemaRef: JSONEditorSchema;
    showKnownProperties: boolean;
    modelChange: EventEmitter<any>;
    schemaUpdate: EventEmitter<JSONEditorSchema>;
    requiredCache: {
        [key: string]: boolean;
    };
    initialized: boolean;
    dataTypes: JsonSchemaDataType[];
    propertyCounter: number;
    propertyId: number;
    propertyIndex: PropertyIndex;
    duplicatedFields: Map<string, string>;
    dataTypeMap: Record<string, any>;
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    update(): void;
    /**
     * Updates a property on the model and emits the change event
     *
     * @param propName
     * @param value
     */
    updateProp(id: number | string, value: any): void;
    /**
     * Updates the name of a property
     *
     * @param id
     * @param name
     */
    updatePropertyName(id: number | string, name: string): void;
    /**
     * Adds a new property to the model
     */
    addProperty(dataType: JsonSchemaDataType): void;
    /**
     * Adds a new property as defined in the schema
     */
    addSchemaProperty(propName: string): void;
    /**
     * Adds a new patternProperty as defined in the schema
     */
    addSchemaPatternProperty(propName: string): void;
    /**
     * Deletes a property
     */
    deleteProperty(propName: string): void;
    /**
     * Returns the absolute tree path of the property
     */
    getPath(propName: string): string;
    /**
     * Updates the required cache
     */
    updateRequiredCache(): void;
    /**
     * Creates an index out of all the properties in the model
     */
    indexProperties(): void;
    isIndexed(propertyName: string): boolean;
    /**
     * Inits the required properties on the model
     */
    addRequiredProperties(): void;
    /**
     *
     * @param property
     * @param type
     */
    changePropertyType(property: JSONEditorSchema, type: string): void;
    /**
     * Track By function for the array ittierator
     *
     * @param index
     * @param value
     */
    trackBy(_: any, value: any): any;
    /**
     * Updates the icons in the schemas
     */
    protected updateIcons(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectNode, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ObjectNode, never, never, { "schema": { "alias": "schema"; "required": false; }; "model": { "alias": "model"; "required": false; }; "required": { "alias": "required"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "path": { "alias": "path"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "typeCheckOverrides": { "alias": "typeCheckOverrides"; "required": false; }; "schemaBuilderMode": { "alias": "schemaBuilderMode"; "required": false; }; "schemaRef": { "alias": "schemaRef"; "required": false; }; "showKnownProperties": { "alias": "showKnownProperties"; "required": false; }; }, { "modelChange": "modelChange"; "schemaUpdate": "schemaUpdate"; }, never, never, true, never>;
}

declare class ObjectNodeComponent extends ObjectNode {
    protected cdr: ChangeDetectorRef;
    isDuplicated: boolean;
    passwordToggleEnabled: boolean;
    constructor(cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectNodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectNodeComponent, "ngx-json-object-node", never, { "isDuplicated": { "alias": "isDuplicated"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ArrayNode implements OnChanges {
    schema: JSONEditorSchema;
    model: any[];
    required: boolean;
    expanded: boolean;
    path: string;
    errors: any[];
    typeCheckOverrides?: any;
    schemaRef: JSONEditorSchema;
    showKnownProperties: boolean;
    modelChange: EventEmitter<any[]>;
    schemaUpdate: EventEmitter<JSONEditorSchema>;
    requiredCache: any;
    schemas: JSONEditorSchema[];
    dataTypes: JsonSchemaDataType[];
    dataTypeMap: Record<string, any>;
    _array: ArrayConstructor;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * Updates an array item of the model and emits the change event
     *
     * @param index
     * @param value
     */
    updateArrayItem(index: number, value: any): void;
    /**
     * Adds a new item to the model
     */
    addArrayItem(dataType?: JsonSchemaDataType): void;
    /**
     * Deletes an item from the array
     *
     * @param index
     */
    deleteArrayItem(index: number): void;
    /**
     * Track By function for the array ittierator
     *
     * @param index
     * @param value
     */
    arrayTrackBy(index: number): number;
    /**
     *
     * @param property
     * @param type
     */
    changeItemType(index: number, type: string): void;
    private getTypeFromSchemaProperty;
    /**
     * Infers the schema type for each item in the array
     */
    private initSchemasTypeByModelValue;
    /**
     * Updates the icons in the schemas
     */
    private updateIcons;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayNode, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ArrayNode, never, never, { "schema": { "alias": "schema"; "required": false; }; "model": { "alias": "model"; "required": false; }; "required": { "alias": "required"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "path": { "alias": "path"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "typeCheckOverrides": { "alias": "typeCheckOverrides"; "required": false; }; "schemaRef": { "alias": "schemaRef"; "required": false; }; "showKnownProperties": { "alias": "showKnownProperties"; "required": false; }; }, { "modelChange": "modelChange"; "schemaUpdate": "schemaUpdate"; }, never, never, true, never>;
}

declare class ArrayNodeComponent extends ArrayNode {
    isDuplicated: boolean;
    passwordToggleEnabled: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayNodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayNodeComponent, "ngx-json-array-node", never, { "isDuplicated": { "alias": "isDuplicated"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class JsonEditorNodeFlatComponent extends JsonEditorNode implements OnInit, OnChanges, OnDestroy {
    dialogMngr: DialogService;
    private dateFormat;
    model: any;
    schema: JSONEditorSchema;
    typeCheckOverrides?: any;
    errors: any[];
    label: string;
    level: number;
    schemaBuilderMode?: boolean;
    schemaRef?: JSONEditorSchema;
    formats: JsonSchemaDataType[];
    arrayItem: boolean;
    hideRoot: boolean;
    arrayName: string;
    indentationArray: number[];
    showKnownProperties: boolean;
    isDuplicated: boolean;
    passwordToggleEnabled: boolean;
    inputControlTemplate: TemplateRef<unknown>;
    updatePropertyNameEvent: EventEmitter<{
        id: string | number;
        name: string;
    }>;
    nextLevel: number;
    contextItem: JSONEditorTemplateProperty;
    nodeChangeValue$: Subject<unknown>;
    nodeExpandTrigger$: Subject<boolean>;
    private readonly unsub$;
    constructor(dialogMngr: DialogService, dateFormat: DateFormatPipe);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    updatePropertyName(id: string | number, name: string): void;
    triggerExpand(value: boolean): void;
    updateDateTime(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditorNodeFlatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JsonEditorNodeFlatComponent, "ngx-json-editor-node-flat", never, { "model": { "alias": "model"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "typeCheckOverrides": { "alias": "typeCheckOverrides"; "required": false; }; "errors": { "alias": "errors"; "required": false; }; "label": { "alias": "label"; "required": false; }; "level": { "alias": "level"; "required": false; }; "schemaBuilderMode": { "alias": "schemaBuilderMode"; "required": false; }; "schemaRef": { "alias": "schemaRef"; "required": false; }; "formats": { "alias": "formats"; "required": false; }; "arrayItem": { "alias": "arrayItem"; "required": false; }; "hideRoot": { "alias": "hideRoot"; "required": false; }; "arrayName": { "alias": "arrayName"; "required": false; }; "indentationArray": { "alias": "indentationArray"; "required": false; }; "showKnownProperties": { "alias": "showKnownProperties"; "required": false; }; "isDuplicated": { "alias": "isDuplicated"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; "inputControlTemplate": { "alias": "inputControlTemplate"; "required": false; }; }, { "updatePropertyNameEvent": "updatePropertyNameEvent"; }, never, ["[cdkDragHandle]", "[node-options]"], false, never>;
}

interface PropertyConfigOptions {
    required: boolean;
    index: number;
    newProperty: JSONEditorSchema;
    oldProperty: JSONEditorSchema;
}
declare class PropertyConfigComponent implements OnInit {
    property: JSONEditorSchema;
    index?: number;
    schema: JSONEditorSchema;
    formats: JsonSchemaDataType[];
    arrayItem?: boolean;
    rootItem?: boolean;
    isNew: boolean;
    updateProperty: EventEmitter<PropertyConfigOptions>;
    propTypes: string[];
    editableProperty: JSONEditorSchema;
    required: boolean;
    isNameLocked: boolean;
    canChangeType: boolean;
    newEnumValue: string;
    ngOnInit(): void;
    applyChanges(): void;
    updateType(type: string): void;
    updateExamples(examples: string[]): void;
    updateFormat(format: string): void;
    addEnumValue(): void;
    updateDefault(enumValue: string): void;
    removeEnumValue(val: string): void;
    onTitleChange(title: string): void;
    private cleanUpPropertyConstrains;
    private setRequired;
    static ɵfac: i0.ɵɵFactoryDeclaration<PropertyConfigComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PropertyConfigComponent, "ngx-property-config", never, { "property": { "alias": "property"; "required": false; }; "index": { "alias": "index"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "formats": { "alias": "formats"; "required": false; }; "arrayItem": { "alias": "arrayItem"; "required": false; }; "rootItem": { "alias": "rootItem"; "required": false; }; "isNew": { "alias": "isNew"; "required": false; }; }, { "updateProperty": "updateProperty"; }, never, never, false, never>;
}

declare class JsonEditorFlatComponent extends JsonEditor implements OnInit, OnChanges {
    private dialogService;
    protected schemaValidatorService: SchemaValidatorService;
    protected cdr: ChangeDetectorRef;
    model: any;
    schema: JSONEditorSchema;
    typeCheckOverrides?: any;
    schemaBuilderMode?: boolean;
    formats?: string[];
    hideRoot: boolean;
    showKnownProperties: boolean;
    passwordToggleEnabled: boolean;
    enableSchemaValidation: boolean;
    inputControlTemplate: TemplateRef<unknown>;
    nodeElms: QueryList<JsonEditorNodeFlatComponent>;
    propertyConfigTmpl: TemplateRef<PropertyConfigComponent>;
    schemaRef: JSONEditorSchema;
    customFormats: JsonSchemaDataType[];
    constructor(dialogService: DialogService, schemaValidatorService: SchemaValidatorService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onPropertyConfig(): void;
    validate(schema: any, model: any): boolean;
    updateSchemaProperty(options: PropertyConfigOptions): void;
    private buildCustomFormats;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditorFlatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JsonEditorFlatComponent, "ngx-json-editor-flat", never, { "model": { "alias": "model"; "required": false; }; "schema": { "alias": "schema"; "required": false; }; "typeCheckOverrides": { "alias": "typeCheckOverrides"; "required": false; }; "schemaBuilderMode": { "alias": "schemaBuilderMode"; "required": false; }; "formats": { "alias": "formats"; "required": false; }; "hideRoot": { "alias": "hideRoot"; "required": false; }; "showKnownProperties": { "alias": "showKnownProperties"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; "enableSchemaValidation": { "alias": "enableSchemaValidation"; "required": false; }; "inputControlTemplate": { "alias": "inputControlTemplate"; "required": false; }; }, {}, ["nodeElms"], never, false, never>;
}

declare class JsonEditorNodeInfoComponent {
    nameEditable: boolean;
    required: boolean;
    title: string;
    propertyName: string;
    description: string;
    type: string;
    examples: string[];
    propertyNameChange: EventEmitter<string>;
    updatePropertyName(name: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditorNodeInfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<JsonEditorNodeInfoComponent, "ngx-json-editor-node-info", never, { "nameEditable": { "alias": "nameEditable"; "required": false; }; "required": { "alias": "required"; "required": false; }; "title": { "alias": "title"; "required": false; }; "propertyName": { "alias": "propertyName"; "required": false; }; "description": { "alias": "description"; "required": false; }; "type": { "alias": "type"; "required": false; }; "examples": { "alias": "examples"; "required": false; }; }, { "propertyNameChange": "propertyNameChange"; }, never, never, false, never>;
}

declare class ArrayNodeFlatComponent extends ArrayNode implements OnInit, OnChanges {
    private dialogService;
    propertyConfigTmpl: TemplateRef<PropertyConfigComponent>;
    level: number;
    schemaBuilderMode: boolean;
    formats: JsonSchemaDataType[];
    hideRoot: boolean;
    isDuplicated: boolean;
    passwordToggleEnabled: boolean;
    inputControlTemplate: TemplateRef<unknown>;
    indentationArray: number[];
    constructor(dialogService: DialogService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onPropertyConfig(item: JSONEditorSchema, index: number): void;
    updateSchemaProperty(options: PropertyConfigOptions): void;
    addArrayItem(dataType?: JsonSchemaDataType): void;
    deleteArrayItem(index: number): void;
    addDefaultItemForSchemaBuilder(dataType: JsonSchemaDataType): void;
    private removeDefaultItemForSchemaBuilder;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayNodeFlatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ArrayNodeFlatComponent, "ngx-json-array-node-flat", never, { "level": { "alias": "level"; "required": false; }; "schemaBuilderMode": { "alias": "schemaBuilderMode"; "required": false; }; "formats": { "alias": "formats"; "required": false; }; "hideRoot": { "alias": "hideRoot"; "required": false; }; "isDuplicated": { "alias": "isDuplicated"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; "inputControlTemplate": { "alias": "inputControlTemplate"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ObjectNodeFlatComponent extends ObjectNode implements OnInit, OnChanges {
    private dialogService;
    protected cdr: ChangeDetectorRef;
    propertyConfigTmpl: TemplateRef<PropertyConfigComponent>;
    level: number;
    schemaBuilderMode: boolean;
    formats: JsonSchemaDataType[];
    hideRoot: boolean;
    isDuplicated: boolean;
    passwordToggleEnabled: boolean;
    inputControlTemplate: TemplateRef<unknown>;
    indentationArray: number[];
    duplicatedFields: Map<string, string>;
    objectKeys: {
        (o: object): string[];
        (o: {}): string[];
    };
    get isRoot(): boolean;
    get indentAdd(): boolean;
    constructor(dialogService: DialogService, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onUpdatePropertyName(options: {
        id: string;
        name: string;
    }): void;
    onPropertyConfig(property: JSONEditorSchema, index: number, isNew?: boolean): void;
    updateSchemaProperty(options: PropertyConfigOptions): void;
    addProperty(dataType: JsonSchemaDataType): void;
    deleteProperty(propName: string): void;
    drop(event: CdkDragDrop<string[]>): void;
    private swapSchemaProperties;
    private initSchemaProperties;
    private updateSchemaRefProperty;
    private updateSchemaPropertyName;
    private toggleRequiredValue;
    private updateRequiredProperties;
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectNodeFlatComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ObjectNodeFlatComponent, "ngx-json-object-node-flat", never, { "level": { "alias": "level"; "required": false; }; "schemaBuilderMode": { "alias": "schemaBuilderMode"; "required": false; }; "formats": { "alias": "formats"; "required": false; }; "hideRoot": { "alias": "hideRoot"; "required": false; }; "isDuplicated": { "alias": "isDuplicated"; "required": false; }; "passwordToggleEnabled": { "alias": "passwordToggleEnabled"; "required": false; }; "inputControlTemplate": { "alias": "inputControlTemplate"; "required": false; }; }, {}, never, never, false, never>;
}

interface DataValue {
    value: string;
}
declare class OrderableInputsListComponent implements OnInit {
    data: string[];
    onUpdate: EventEmitter<string[]>;
    dataValues: DataValue[];
    ngOnInit(): void;
    addExample(): void;
    removeItem(index: number): void;
    drop(event: CdkDragDrop<string[]>): void;
    update(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<OrderableInputsListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<OrderableInputsListComponent, "ngx-orderable-inputs-list", never, { "data": { "alias": "data"; "required": false; }; }, { "onUpdate": "onUpdate"; }, never, never, false, never>;
}

declare class ObjectValuesPipe implements PipeTransform {
    transform(object: any): unknown[];
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectValuesPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ObjectValuesPipe, "objectValues", false>;
}

declare class IfTabActiveDirective {
    templateRef: TemplateRef<any>;
    constructor(templateRef: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<IfTabActiveDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IfTabActiveDirective, "[ngxIfTabActive]", never, {}, {}, never, never, false, never>;
}

/**
 * TODO: Remove hidden when https://github.com/angular/angular/issues/18310 is resolved
 */
declare class TabComponent implements OnInit, OnChanges {
    private cdr;
    private renderer;
    private elRef;
    id: string;
    tabId: string;
    role: string;
    title: string;
    label: string | TemplateRef<any>;
    active: boolean;
    disabled: boolean;
    inputChanges: EventEmitter<SimpleChanges>;
    labelStringTemplate: any;
    template: IfTabActiveDirective;
    labelTemplate: TemplateRef<any>;
    constructor(cdr: ChangeDetectorRef, renderer: Renderer2, elRef: ElementRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    detectChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabComponent, "ngx-tab", never, { "title": { "alias": "title"; "required": false; }; "label": { "alias": "label"; "required": false; }; "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "inputChanges": "inputChanges"; }, ["template"], ["*"], false, never>;
}

declare enum TabsAppearance {
    Legacy = "legacy",
    Light = "light"
}

declare class TabsComponent implements AfterContentInit, OnDestroy {
    readonly cdr: ChangeDetectorRef;
    get light(): boolean;
    vertical: boolean;
    selectTab: EventEmitter<any>;
    select: EventEmitter<any>;
    appearance: TabsAppearance;
    readonly tabs: QueryList<TabComponent>;
    get horizontalClass(): boolean;
    get verticalClass(): boolean;
    private tabEvents;
    get index(): number;
    private readonly _destroy$;
    constructor(cdr: ChangeDetectorRef);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    tabClicked(activeTab: TabComponent): void;
    move(offset: number): void;
    next(): void;
    prev(): void;
    private setupTabInputWatcher;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "ngx-tabs", ["ngxTabs"], { "vertical": { "alias": "vertical"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; }, { "selectTab": "selectTab"; "select": "select"; }, ["tabs"], ["*"], false, never>;
}

declare class TabsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TabsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TabsModule, [typeof TabComponent, typeof TabsComponent, typeof IfTabActiveDirective], [typeof i2.CommonModule], [typeof TabComponent, typeof TabsComponent, typeof IfTabActiveDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TabsModule>;
}

declare class JsonEditorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<JsonEditorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<JsonEditorModule, [typeof JsonEditorComponent, typeof JsonEditorNodeComponent, typeof ObjectNodeComponent, typeof ArrayNodeComponent, typeof JsonEditorFlatComponent, typeof JsonEditorNodeFlatComponent, typeof JsonEditorNodeInfoComponent, typeof ArrayNodeFlatComponent, typeof ObjectNodeFlatComponent, typeof PropertyConfigComponent, typeof OrderableInputsListComponent, typeof ObjectValuesPipe], [typeof CheckboxModule, typeof i2.CommonModule, typeof i15.DragDropModule, typeof i3.FormsModule, typeof PipesModule, typeof InputModule, typeof ButtonModule, typeof CodeEditorModule, typeof TooltipModule, typeof DropdownModule, typeof IconModule, typeof ToggleModule, typeof SelectModule, typeof TabsModule], [typeof JsonEditorComponent, typeof JsonEditorNodeComponent, typeof ObjectNodeComponent, typeof ArrayNodeComponent, typeof JsonEditorFlatComponent, typeof JsonEditorNodeFlatComponent, typeof JsonEditorNodeInfoComponent, typeof ArrayNodeFlatComponent, typeof ObjectNodeFlatComponent, typeof PropertyConfigComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<JsonEditorModule>;
}

declare class ListColumnTemplateDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ListColumnTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListColumnTemplateDirective, "[ngx-list-column-template]", never, {}, {}, never, never, false, never>;
}

interface ListColumnInput {
    columnTemplate: TemplateRef<any>;
    template: TemplateRef<any>;
}
declare class ListColumnComponent {
    template: TemplateRef<any>;
    column: ListColumnInput;
    data: Record<string, unknown>;
    rowIndex: number;
    columnTemplate: TemplateRef<ListColumnTemplateDirective>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListColumnComponent, "ngx-list-column", never, { "column": { "alias": "column"; "required": false; }; "data": { "alias": "data"; "required": false; }; "rowIndex": { "alias": "rowIndex"; "required": false; }; }, {}, ["columnTemplate"], never, false, never>;
}

declare enum ListRowStatus {
    Error = "error",
    Success = "success",
    Warning = "warning"
}

declare class ListRowComponent {
    columnLayout: Partial<CSSStyleDeclaration>;
    columns: QueryList<ListColumnComponent>;
    data: Record<string, unknown>;
    index: number;
    status: ListRowStatus;
    rowHeight: number | string;
    columnComponent: typeof ListColumnComponent;
    readonly ListRowStatus: typeof ListRowStatus;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListRowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListRowComponent, "ngx-list-row", never, { "columnLayout": { "alias": "columnLayout"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "index": { "alias": "index"; "required": false; }; "status": { "alias": "status"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ListHeaderTemplateDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ListHeaderTemplateDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ListHeaderTemplateDirective, "[ngx-list-header-template]", never, {}, {}, never, never, false, never>;
}

declare class ListHeaderComponent {
    template: TemplateRef<any>;
    header: any;
    headerTemplate: TemplateRef<ListHeaderTemplateDirective>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListHeaderComponent, "ngx-list-header", never, { "header": { "alias": "header"; "required": false; }; }, {}, ["headerTemplate"], never, false, never>;
}

interface ListPaginationConfig {
    /**
     * The number of rows per page
     */
    pageSize: number;
    /**
     * The page to start on when the list is rendered
     * Only supported when virtual scroll is disabled
     */
    index?: number;
}

declare class ListComponent implements AfterContentInit, AfterViewInit, OnDestroy {
    columnLayout: Partial<CSSStyleDeclaration>;
    dataSource: Array<Record<string, unknown>>;
    height: number;
    paginationConfig: ListPaginationConfig;
    virtualScroll: boolean;
    rowHeight: number;
    onPageChange: EventEmitter<number>;
    onScroll: EventEmitter<number>;
    row: ListRowComponent;
    columns: QueryList<ListColumnComponent>;
    headers: QueryList<ListHeaderComponent>;
    listRowsContainer: ElementRef<HTMLDivElement>;
    virtualScrollViewport: CdkVirtualScrollViewport;
    headerComponent: typeof ListHeaderComponent;
    rowComponent: typeof ListRowComponent;
    _columnLayout: Partial<CSSStyleDeclaration>;
    hasScrollbar: boolean;
    page: number;
    private destroy$;
    ngAfterContentInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * @function emitScrollChanges
     *
     * @description
     * Emits the `onScroll` event. Additionally, if the `paginationConfig` input is provided, emits the `onPageChange` event.
     *
     * @param {Event} event - the scroll event
     */
    emitScrollChanges(event: Event): void;
    /**
     * @function generateLayout
     *
     * @description
     * Generates the column layout styling.
     */
    generateLayout(): void;
    /**
     * @function initScrollListener
     *
     * @description
     * Initializes the appropriate scroll listener.
     */
    initScrollListener(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ListComponent, "ngx-list", never, { "columnLayout": { "alias": "columnLayout"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "height": { "alias": "height"; "required": false; }; "paginationConfig": { "alias": "paginationConfig"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; }, { "onPageChange": "onPageChange"; "onScroll": "onScroll"; }, ["row", "columns", "headers"], never, false, never>;
}

declare class ListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ListModule, [typeof ListComponent, typeof ListRowComponent, typeof ListColumnComponent, typeof ListHeaderComponent, typeof ListHeaderTemplateDirective, typeof ListColumnTemplateDirective], [typeof i2.CommonModule, typeof i5$2.ScrollingModule], [typeof ListComponent, typeof ListRowComponent, typeof ListColumnComponent, typeof ListHeaderComponent, typeof ListHeaderTemplateDirective, typeof ListColumnTemplateDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ListModule>;
}

declare class LoadingComponent {
    private cdr;
    get visible(): boolean;
    set visible(visible: boolean);
    get progress(): number;
    set progress(progress: number);
    private _visible;
    private _progress;
    constructor(cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingComponent, "ngx-loading-bar", ["ngxLoadingBar"], { "visible": { "alias": "visible"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class LoadingService {
    private readonly injectionService;
    threshold: number;
    set progress(val: number);
    get progress(): number;
    get count(): number;
    private get instance();
    private _count;
    private timeout;
    private component;
    private _progress;
    constructor(injectionService: InjectionService);
    start(autoIncrement?: boolean): void;
    stop(): void;
    reset(num?: number): void;
    complete(all?: boolean): void;
    hide(): void;
    private create;
    private increment;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoadingService>;
}

declare const enum State {
    open = "open",
    peek = "peek",
    closed = "closed"
}
declare class NagComponent implements OnDestroy, OnChanges {
    cssClass: string;
    state: State | keyof typeof State;
    stateChanged: EventEmitter<string>;
    get zIndex(): number;
    set zIndex(val: number);
    nagTitle: string;
    watch: any;
    hide: any;
    get klass(): string;
    bounce: number;
    private _zIndex;
    toggle(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NagComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NagComponent, "ngx-nag", ["ngxNag"], { "cssClass": { "alias": "cssClass"; "required": false; }; "state": { "alias": "state"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "nagTitle": { "alias": "nagTitle"; "required": false; }; "watch": { "alias": "watch"; "required": false; }; "hide": { "alias": "hide"; "required": false; }; }, { "stateChanged": "stateChanged"; }, never, ["[ngx-nag-title]", "*"], false, never>;
}

/**
 * Toolbar Title Directive
 * See: https://github.com/angular/angular/issues/11251
 */
declare class ToolbarTitleDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarTitleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarTitleDirective, "ngx-toolbar-title", never, {}, {}, never, never, false, never>;
}

/**
 * Toolbar Content Directive
 * See: https://github.com/angular/angular/issues/11251
 */
declare class ToolbarContentDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ToolbarContentDirective, "ngx-toolbar-content", never, {}, {}, never, never, false, never>;
}

interface ToolbarMenuItem {
    label: string;
    disabled: boolean;
    dropdown: boolean;
    click: (event: Event) => any;
}

declare class ToolbarComponent implements OnInit {
    private renderer;
    private elRef;
    title: string;
    mainTitle: string;
    subtitle: string;
    menu: ToolbarMenuItem[];
    menuClick: EventEmitter<any>;
    toolbarTitle: ToolbarTitleDirective;
    toolbarContent: ToolbarContentDirective;
    get toolbarItems(): ToolbarMenuItem[];
    get dropdownItems(): ToolbarMenuItem[];
    constructor(renderer: Renderer2, elRef: ElementRef);
    onMenuClicked(item: ToolbarMenuItem, $event: Event): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "ngx-toolbar", never, { "title": { "alias": "title"; "required": false; }; "mainTitle": { "alias": "mainTitle"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; }, { "menuClick": "menuClick"; }, never, ["ngx-toolbar-title", "ngx-toolbar-content"], false, never>;
}

declare class ToolbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ToolbarModule, [typeof ToolbarComponent, typeof ToolbarTitleDirective, typeof ToolbarContentDirective], [typeof i2.CommonModule, typeof DropdownModule], [typeof ToolbarComponent, typeof ToolbarTitleDirective, typeof ToolbarContentDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ToolbarModule>;
}

declare class NagModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NagModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NagModule, [typeof NagComponent], [typeof i2.CommonModule, typeof ToolbarModule, typeof IconModule], [typeof NagComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NagModule>;
}

declare class NavMenuComponent {
    get expanded(): boolean;
    set expanded(expanded: boolean);
    private _expanded;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavMenuComponent, "ngx-nav-menu", ["ngxNavMenu"], { "expanded": { "alias": "expanded"; "required": false; }; }, {}, never, ["*"], false, never>;
}

declare class NavMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NavMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NavMenuModule, [typeof NavMenuComponent], [typeof i2.CommonModule, typeof IconModule, typeof TooltipModule], [typeof NavMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NavMenuModule>;
}

declare class NavbarItemComponent {
    private readonly _cdr;
    private readonly _el;
    get active(): number;
    set active(v: number);
    get total(): number;
    set total(v: number);
    get index(): number;
    set index(v: number);
    activeChange: EventEmitter<number>;
    get width(): number;
    private _active?;
    private _total?;
    private _index?;
    constructor(_cdr: ChangeDetectorRef, _el: ElementRef<HTMLElement>);
    setActive(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarItemComponent, "ngx-navbar-item", ["ngxNavbarItem"], { "active": { "alias": "active"; "required": false; }; "total": { "alias": "total"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, { "activeChange": "activeChange"; }, never, ["*"], false, never>;
}

declare enum NavbarBarAnimationStates {
    Animated = "animated"
}

declare class NavbarComponent implements AfterViewInit, OnDestroy {
    private readonly _el;
    private readonly _cdr;
    get barAtTop(): boolean;
    set barAtTop(v: boolean);
    get active(): number;
    set active(v: number);
    activeChange: EventEmitter<number>;
    get navItems(): QueryList<NavbarItemComponent>;
    set navItems(v: QueryList<NavbarItemComponent>);
    get complete(): number;
    get barState(): NavbarBarAnimationStates;
    readonly BAR_SIZE = 40;
    private _active;
    private _barAtTop;
    private _navItems?;
    private _barState;
    private readonly _destroy$;
    private get _name();
    constructor(_el: ElementRef<HTMLElement>, _cdr: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    goTo(index: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NavbarComponent, "ngx-navbar", ["ngxNavbar"], { "barAtTop": { "alias": "barAtTop"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, { "activeChange": "activeChange"; }, ["navItems"], ["ngx-navbar-item"], false, never>;
}

declare class NavbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NavbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NavbarModule, [typeof NavbarComponent, typeof NavbarItemComponent], [typeof i2.CommonModule], [typeof NavbarComponent, typeof NavbarItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NavbarModule>;
}

declare class NotificationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NotificationModule, [typeof NotificationComponent, typeof NotificationContainerComponent], [typeof i2.CommonModule], [typeof NotificationComponent, typeof NotificationContainerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NotificationModule>;
}

declare enum NotificationPermissionType {
    default = "default",
    granted = "granted",
    denied = "denied"
}

declare enum ProgressSpinnerMode {
    Indeterminate = "indeterminate",
    Determinate = "determinate"
}

declare enum SpinnerAppearance {
    Default = "default",
    Icon = "icon"
}
interface SpinnerLabel {
    inProgressLabel: string;
    completeLabel: string;
    failLabel: string;
}
declare class ProgressSpinnerComponent {
    private readonly _cdr;
    mode: ProgressSpinnerMode;
    color: string;
    failStatusColor: string;
    appearance: SpinnerAppearance;
    inProgressIcon?: TemplateRef<any>;
    completeIcon?: TemplateRef<any>;
    failIcon?: TemplateRef<any>;
    isFailure: boolean;
    spinnerLabel?: SpinnerLabel;
    get value(): number;
    set value(v: number);
    get total(): number;
    set total(t: number);
    get diameter(): number;
    set diameter(d: number);
    get strokeWidth(): number;
    set strokeWidth(s: number);
    get radius(): number;
    get strokeDasharray(): string;
    get strokeDashoffset(): number;
    get percentage(): number;
    get isComplete(): boolean;
    get indeterminateClass(): boolean;
    get spinnerColor(): string;
    get showIcon(): boolean;
    readonly uid: string;
    readonly ProgressSpinnerMode: typeof ProgressSpinnerMode;
    private _value;
    private _total;
    private _diameter;
    private _strokeWidth;
    private readonly _indeterminate;
    private get _circumference();
    private get _modeValue();
    private get _modeTotal();
    constructor(_cdr: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<ProgressSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ProgressSpinnerComponent, "ngx-progress-spinner", ["ngxProgressSpinner"], { "mode": { "alias": "mode"; "required": false; }; "color": { "alias": "color"; "required": false; }; "failStatusColor": { "alias": "failStatusColor"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "inProgressIcon": { "alias": "inProgressIcon"; "required": false; }; "completeIcon": { "alias": "completeIcon"; "required": false; }; "failIcon": { "alias": "failIcon"; "required": false; }; "isFailure": { "alias": "isFailure"; "required": false; }; "spinnerLabel": { "alias": "spinnerLabel"; "required": false; }; "value": { "alias": "value"; "required": false; }; "total": { "alias": "total"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "spinnerColor": { "alias": "spinnerColor"; "required": false; }; }, {}, never, never, false, never>;
}

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

declare class RadioButtonComponent implements ControlValueAccessor {
    private readonly cdr;
    private readonly elementRef;
    readonly UNIQUE_ID: string;
    onClick(ev: Event): void;
    id: string;
    name: string;
    radioId: string;
    tabindex: number;
    get checked(): boolean;
    set checked(checked: boolean);
    get value(): any;
    set value(value: any);
    get disabled(): boolean;
    set disabled(disabled: boolean);
    change: EventEmitter<any>;
    blur: EventEmitter<Event>;
    focus: EventEmitter<FocusEvent>;
    groupDisabled: boolean;
    isInGroup: boolean;
    private _checked;
    private _value;
    private _disabled;
    constructor(cdr: ChangeDetectorRef, elementRef: ElementRef);
    _onInputChange(event: Event): void;
    writeValue(value: any): void;
    onFocus(e: FocusEvent): void;
    focusElement(): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onSpace(ev: Event): void;
    toggle(): void;
    private onChangeCallback;
    private onTouchedCallback;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonComponent, "ngx-radiobutton", ["ngxRadiobutton"], { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "radioId": { "alias": "radioId"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "change": "change"; "blur": "blur"; "focus": "focus"; }, never, ["*"], false, never>;
}

declare class RadioButtonGroupComponent implements ControlValueAccessor, OnDestroy, OnChanges, AfterContentInit {
    private readonly _cdr;
    readonly UNIQUE_ID: string;
    id: string;
    get disabled(): boolean;
    set disabled(val: boolean);
    get value(): any;
    set value(value: any);
    get name(): string;
    set name(name: string);
    get focusIndex(): number;
    set focusIndex(val: number);
    get tabIndex(): number;
    set tabIndex(val: number);
    change: EventEmitter<boolean>;
    blur: EventEmitter<Event>;
    focus: EventEmitter<FocusEvent>;
    readonly _radios: QueryList<RadioButtonComponent>;
    get selected(): RadioButtonComponent;
    private _name;
    private _value;
    private _disabled;
    private _selected;
    private _focusIndex;
    private _tabIndex;
    private _destroy$;
    constructor(_cdr: ChangeDetectorRef);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(): void;
    onFocus(): void;
    onKeyUp(ev: KeyboardEvent): void;
    subscribeToRadios(): void;
    onRadioSelected(value: string): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onChangeCallback(_: any): void;
    onTouchedCallback(): void;
    focusFirst(): void;
    setDisabledState(isDisabled: boolean): void;
    private selectIndex;
    private focusOn;
    /**
     * Moves focus to next radio button in the group.
     * +1 is next radio button, -1 is previous radio button.
     */
    private focusIn;
    private update;
    private _updateRadioButtonNames;
    private _updateSelectedRadioFromValue;
    private _updateRadioDisabledState;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadioButtonGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadioButtonGroupComponent, "ngx-radiobutton-group", ["ngxRadiobuttonGroup"], { "id": { "alias": "id"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "required": false; }; "focusIndex": { "alias": "focusIndex"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "change": "change"; "blur": "blur"; "focus": "focus"; }, ["_radios"], ["*"], false, never>;
}

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

declare class SectionHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<SectionHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SectionHeaderComponent, "ngx-section-header", ["ngxSectionHeader"], {}, {}, never, ["*"], false, never>;
}

declare enum SectionAppearance {
    Legacy = "legacy",
    Outline = "outline",
    Light = "light",
    Minimal = "minimal"
}

declare enum TogglePosition {
    Left = "left",
    Right = "right",
    None = "none"
}

declare class SectionComponent {
    id: string;
    get outline(): boolean;
    get light(): boolean;
    get minimal(): boolean;
    sectionCollapsed: boolean;
    sectionCollapsible: boolean;
    headerToggle: boolean;
    sectionTitle: string;
    padding: any;
    appearance: SectionAppearance;
    togglePosition: TogglePosition;
    toggle: EventEmitter<any>;
    headerComp: SectionHeaderComponent;
    readonly TogglePosition: typeof TogglePosition;
    onSectionClicked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SectionComponent, "ngx-section", ["ngxSection"], { "id": { "alias": "id"; "required": false; }; "sectionCollapsed": { "alias": "sectionCollapsed"; "required": false; }; "sectionCollapsible": { "alias": "sectionCollapsible"; "required": false; }; "headerToggle": { "alias": "headerToggle"; "required": false; }; "sectionTitle": { "alias": "sectionTitle"; "required": false; }; "padding": { "alias": "padding"; "required": false; }; "appearance": { "alias": "appearance"; "required": false; }; "togglePosition": { "alias": "togglePosition"; "required": false; }; }, { "toggle": "toggle"; }, ["headerComp"], ["ngx-section-header", "*"], false, never>;
}

declare class SectionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SectionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SectionModule, [typeof SectionComponent, typeof SectionHeaderComponent], [typeof i2.CommonModule, typeof IconModule], [typeof SectionComponent, typeof SectionHeaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SectionModule>;
}

declare class SliderComponent implements ControlValueAccessor, OnInit {
    private cdr;
    id: string;
    min: number;
    max: number;
    step: number;
    orientation: string;
    filled: boolean;
    multiple: boolean;
    disabled: boolean;
    showTicks: boolean;
    tickStep: number;
    change: EventEmitter<any>;
    _values: number[];
    _percents: number[];
    _thumbs: any[];
    _fill: any;
    _ticks: any[];
    _active: any[];
    active: boolean;
    get value(): any;
    set value(val: any);
    get percent(): string;
    get isHorizontal(): boolean;
    get isVertical(): boolean;
    constructor(cdr: ChangeDetectorRef);
    ngOnInit(): void;
    setValues(values: number[]): void;
    setActive(index: number, active: boolean): void;
    setValue(val: number, index: number): void;
    getCount(): any;
    getTicks(): any;
    getFill(): any;
    onMouseDown(event: any): void;
    onMouseUp(event: any): void;
    onChange(event: any): void;
    writeValue(val: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    trackIndex(index: any): any;
    onChangeCallback: (_: any) => void;
    onTouchedCallback: (_: any) => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SliderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SliderComponent, "ngx-slider", ["ngxSlider"], { "id": { "alias": "id"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "filled": { "alias": "filled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "showTicks": { "alias": "showTicks"; "required": false; }; "tickStep": { "alias": "tickStep"; "required": false; }; }, { "change": "change"; }, never, never, false, never>;
}

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

type FlexParts = [string, string, string];

declare function validateBasis(basis: string, grow?: string, shrink?: string): FlexParts;
declare class SplitAreaDirective implements OnChanges {
    private ref;
    ngxSplitArea: string;
    minBasis: string;
    maxBasis: string;
    shouldAdjustMaxMin: boolean;
    overflow: string;
    initialFlexParts: FlexParts;
    currentFlexParts: FlexParts;
    get flex(): string;
    get maxWidth(): string;
    get minWidth(): string;
    constructor(ref: ChangeDetectorRef);
    ngOnChanges(): void;
    updateBasis(newBasis: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitAreaDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SplitAreaDirective, "[ngxSplitArea]", ["ngxSplitArea"], { "ngxSplitArea": { "alias": "ngxSplitArea"; "required": false; }; "minBasis": { "alias": "minBasis"; "required": false; }; "maxBasis": { "alias": "maxBasis"; "required": false; }; "shouldAdjustMaxMin": { "alias": "shouldAdjustMaxMin"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum SplitDirection {
    Row = "row",
    Column = "column"
}

declare class SplitHandleComponent implements OnChanges {
    ngxSplitHandle: string;
    drag: EventEmitter<{
        x: number;
        y: number;
    }>;
    dragStart: EventEmitter<MouseEvent>;
    dragEnd: EventEmitter<MouseEvent>;
    dblclick: EventEmitter<MouseEvent>;
    direction: SplitDirection;
    subscription: Subscription;
    currentFlexParts: FlexParts;
    get flex(): string;
    get isRow(): boolean;
    get isColumn(): boolean;
    ngOnChanges(): void;
    onMousedown(ev: MouseEvent): void;
    onMouseMove(ev: MouseEvent): void;
    onMouseup(ev: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitHandleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SplitHandleComponent, "[ngxSplitHandle]", ["ngxSplitHandle"], { "ngxSplitHandle": { "alias": "ngxSplitHandle"; "required": false; }; }, { "drag": "drag"; "dragStart": "dragStart"; "dragEnd": "dragEnd"; "dblclick": "dblclick"; }, never, never, false, never>;
}

declare class SplitDirective implements AfterContentInit, OnChanges, OnDestroy {
    private readonly elementRef;
    splitDirection: SplitDirection;
    get rowCss(): boolean;
    get columnCss(): boolean;
    readonly handles: QueryList<SplitHandleComponent>;
    readonly areas: QueryList<SplitAreaDirective>;
    private subscriptions;
    constructor(elementRef: ElementRef);
    ngAfterContentInit(): void;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    resize(delta: number): void;
    private updateHandles;
    private onDblClick;
    private onDrag;
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SplitDirective, "[ngxSplit]", ["ngxSplit"], { "splitDirection": { "alias": "splitDirection"; "required": false; }; }, {}, ["handles", "areas"], never, false, never>;
}

declare class SplitModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SplitModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SplitModule, [typeof SplitDirective, typeof SplitAreaDirective, typeof SplitHandleComponent], [typeof i2.CommonModule], [typeof SplitDirective, typeof SplitAreaDirective, typeof SplitHandleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SplitModule>;
}

declare class StepContentDirective {
    readonly template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<StepContentDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<StepContentDirective, "ng-template[ngxStepContent]", ["ngxStepContent"], {}, {}, never, never, false, never>;
}

declare class StepComponent implements OnInit {
    private readonly _cdr;
    private readonly _el;
    label?: string;
    get icon(): string;
    set icon(v: string);
    get completeIcon(): string;
    set completeIcon(v: string);
    get active(): number;
    set active(v: number);
    get step(): number;
    set step(v: number);
    get total(): number;
    set total(v: number);
    activeChange: EventEmitter<number>;
    readonly content?: QueryList<StepContentDirective>;
    get height(): number;
    get width(): number;
    get stepHeight(): number;
    get stepWidth(): number;
    private _active?;
    private _step?;
    private _total?;
    private _icon?;
    private _completeIcon?;
    constructor(_cdr: ChangeDetectorRef, _el: ElementRef<HTMLElement>);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepComponent, "ngx-step", ["ngxStep"], { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "completeIcon": { "alias": "completeIcon"; "required": false; }; "active": { "alias": "active"; "required": false; }; "step": { "alias": "step"; "required": false; }; "total": { "alias": "total"; "required": false; }; }, { "activeChange": "activeChange"; }, ["content"], never, false, never>;
}

declare enum StepperAnimationStates {
    Left = "left",
    Right = "right",
    Current = "current",
    Up = "up",
    Down = "down"
}

declare enum StepperBarAnimationStates {
    Move = "move",
    Stay = "stay"
}

declare enum StepperPosition {
    Top = "top",
    Bottom = "bottom",
    Left = "left",
    Right = "right"
}

declare class StepperComponent implements OnDestroy {
    private readonly _cdr;
    position: StepperPosition;
    get completeIcon(): string;
    set completeIcon(v: string);
    get active(): number;
    set active(v: number);
    get readonly(): boolean;
    set readonly(v: boolean);
    get progress(): boolean;
    set progress(v: boolean);
    get large(): boolean;
    set large(v: boolean);
    get removeHighlight(): boolean;
    set removeHighlight(v: boolean);
    get trackBar(): boolean;
    set trackBar(v: boolean);
    activeChange: EventEmitter<number>;
    get steps(): QueryList<StepComponent>;
    set steps(v: QueryList<StepComponent>);
    get completeSteps(): number;
    get vertical(): boolean;
    get barState(): StepperBarAnimationStates;
    readonly StepperPosition: typeof StepperPosition;
    private _active;
    private _readonly;
    private _trackBar;
    private _progress;
    private _large;
    private _removeHighlight;
    private _completeIcon;
    private _steps?;
    private _barState;
    private readonly _destroy$;
    constructor(_cdr: ChangeDetectorRef);
    ngOnDestroy(): void;
    previous(): void;
    next(): void;
    first(): void;
    last(): void;
    complete(): void;
    onResize(): void;
    onStepAnimationStart(i: number): void;
    onStepAnimationEnd(i: number): void;
    getStepState(i: number): StepperAnimationStates;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepperComponent, "ngx-stepper", ["ngxStepper"], { "position": { "alias": "position"; "required": false; }; "completeIcon": { "alias": "completeIcon"; "required": false; }; "active": { "alias": "active"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "large": { "alias": "large"; "required": false; }; "removeHighlight": { "alias": "removeHighlight"; "required": false; }; "trackBar": { "alias": "trackBar"; "required": false; }; }, { "activeChange": "activeChange"; }, ["steps"], ["ngx-step"], false, never>;
}

declare class StepperModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<StepperModule, [typeof StepperComponent, typeof StepComponent, typeof StepContentDirective], [typeof i2.CommonModule, typeof ResizeObserverModule], [typeof StepperComponent, typeof StepComponent, typeof StepContentDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<StepperModule>;
}

interface ColumnCustomComponentOptions {
    index?: number;
    injector?: Injector;
    ngModuleRef?: any;
    environmentInjector?: EnvironmentInjector | any;
    projectableNodes?: Node[][];
    directives?: any[];
    bindings?: Binding[];
}
interface Column {
    id: string;
    active: boolean;
    title: string;
    templateRef?: string;
    children?: Array<Column>;
    content?: {
        width?: string;
        component: any;
        options?: ColumnCustomComponentOptions;
    };
}

interface ColumnTabClickEvent {
    columnId: string;
    active: boolean;
    title: string;
    children?: Array<ColumnTabClickEvent>;
    content?: boolean;
}
declare class ColumnComponent implements OnChanges {
    column: i0.InputSignal<Column>;
    height: i0.InputSignal<string>;
    tabClick: i0.OutputEmitterRef<ColumnTabClickEvent>;
    scrollerHeight: i0.WritableSignal<string>;
    vcr: i0.Signal<ViewContainerRef>;
    activeChild: Column | null;
    list: Column[];
    searchInputValue: string;
    componentRef: ComponentRef<any> | null;
    ngOnChanges(changes: SimpleChanges): void;
    toTabClickEvent(column: Column): ColumnTabClickEvent;
    onChildClick(columnId: string): void;
    onChildKeyup(event: KeyboardEvent, columnId: string): void;
    displayContent(): void;
    onInputChange(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnComponent, "ngx-column", never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, { "tabClick": "tabClick"; }, never, never, false, never>;
}

declare class ColumnsComponent implements OnChanges {
    column: i0.InputSignal<Column>;
    height: i0.InputSignal<string>;
    onColumnChange: i0.OutputEmitterRef<ColumnTabClickEvent>;
    columnHeight: i0.WritableSignal<string>;
    columns: Array<Column>;
    columnComponent: typeof ColumnComponent;
    ngOnChanges(changes: SimpleChanges): void;
    traverseActivePath(column: Column | undefined, columns: Array<Column>): Array<Column>;
    deactivatePath(column: Column | undefined): void;
    getCurrentColumns(): Array<Column>;
    onColumnNavigation(event: ColumnTabClickEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnsComponent, "ngx-columns", never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, { "onColumnChange": "onColumnChange"; }, never, never, false, never>;
}

declare class ColumnModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ColumnModule, [typeof ColumnComponent], [typeof i2.CommonModule, typeof InputModule, typeof IconModule, typeof i5$2.ScrollingModule], [typeof ColumnComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ColumnModule>;
}

declare class ColumnsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ColumnsModule, [typeof ColumnsComponent], [typeof i2.CommonModule, typeof ColumnModule], [typeof ColumnsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ColumnsModule>;
}

interface TreeNode {
    id?: number;
    label: string;
    children?: TreeNode[];
    model: {
        [key: string]: any;
    };
    disabled?: boolean;
    expandable?: boolean;
    expanded?: boolean;
    selectable?: boolean;
    depth?: number;
    display?: boolean;
    childNodesCount?: number;
    parentId?: number;
    index?: number;
}

declare class TreeNodeComponent implements OnChanges {
    label: string;
    model: any;
    node: TreeNode;
    children: any[];
    disabled: boolean;
    expandable: boolean;
    expanded: boolean;
    selectable: boolean;
    template: TemplateRef<any>;
    icons: {
        collapse: string;
        expand: string;
    };
    virtualScrolling: boolean;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    selectNode: EventEmitter<any>;
    select: EventEmitter<any>;
    expand: EventEmitter<any>;
    collapse: EventEmitter<any>;
    data: any;
    depth: number;
    ngOnChanges(): void;
    onExpandClick(event: Event): void;
    onClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeComponent, "ngx-tree-node", ["ngxTreeNode"], { "label": { "alias": "label"; "required": false; }; "model": { "alias": "model"; "required": false; }; "node": { "alias": "node"; "required": false; }; "children": { "alias": "children"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "expandable": { "alias": "expandable"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "template": { "alias": "template"; "required": false; }; "icons": { "alias": "icons"; "required": false; }; "virtualScrolling": { "alias": "virtualScrolling"; "required": false; }; }, { "activate": "activate"; "deactivate": "deactivate"; "selectNode": "selectNode"; "select": "select"; "expand": "expand"; "collapse": "collapse"; }, never, ["*"], false, never>;
}

declare class TreeComponent implements AfterContentInit, OnDestroy, OnChanges {
    private readonly _cdr;
    nodes: TreeNode[];
    virtualScrolling: boolean;
    maxVirtualScrollHeight: number;
    nodeHeight: number;
    _templateInput: TemplateRef<any>;
    icons: {
        collapse: string;
        expand: string;
    };
    _templateQuery: TemplateRef<any>;
    readonly nodeElms: QueryList<TreeNodeComponent>;
    readonly allNodeElms: QueryList<TreeNodeComponent>;
    expand: EventEmitter<any>;
    collapse: EventEmitter<any>;
    activate: EventEmitter<any>;
    deactivate: EventEmitter<any>;
    selectNode: EventEmitter<any>;
    get hasOneLeaf(): boolean;
    get template(): TemplateRef<any>;
    treeStructure: TreeNode[];
    filteredTree: TreeNode[];
    depthPadding: number;
    private readonly _destroy$;
    constructor(_cdr: ChangeDetectorRef);
    ngAfterContentInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onExpand(event: any): void;
    onCollapse(event: any): void;
    applyTreeChanges(tree: TreeNode[]): void;
    filterTree(tree: TreeNode[]): void;
    generateTreeStructure(nodes: TreeNode[]): TreeNode[];
    applyExpandChange(nodes: TreeNode[]): TreeNode[];
    generateAditionalTreeInfo(nodes: TreeNode[]): void;
    elementsToNodes(nodes: QueryList<TreeNodeComponent>): TreeNode[];
    trackBy(_index: number, node: any): number;
    filled(node: TreeNode, filteredTree: TreeNode[], isSingle?: boolean): boolean;
    empty(node: TreeNode, filteredTree: TreeNode[]): boolean;
    dots(node: TreeNode, filteredTree: TreeNode[]): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TreeComponent, "ngx-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "virtualScrolling": { "alias": "virtualScrolling"; "required": false; }; "maxVirtualScrollHeight": { "alias": "maxVirtualScrollHeight"; "required": false; }; "nodeHeight": { "alias": "nodeHeight"; "required": false; }; "_templateInput": { "alias": "template"; "required": false; }; "icons": { "alias": "icons"; "required": false; }; }, { "expand": "expand"; "collapse": "collapse"; "activate": "activate"; "deactivate": "deactivate"; "selectNode": "selectNode"; }, ["_templateQuery", "nodeElms", "allNodeElms"], ["*"], false, never>;
}

declare class TreeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TreeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeModule, [typeof TreeComponent, typeof TreeNodeComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i5$2.ScrollingModule, typeof MemoizeModule], [typeof TreeComponent, typeof TreeNodeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TreeModule>;
}

declare enum TipStatus {
    Success = "success",
    Error = "error",
    Notice = "notice",
    Warning = "warning"
}

declare class TipComponent implements OnChanges, OnDestroy {
    status: TipStatus;
    isCloseable: boolean;
    icon: string;
    close: EventEmitter<any>;
    readonly TipStatus: typeof TipStatus;
    ngOnChanges(): void;
    ngOnDestroy(): void;
    onClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TipComponent, "ngx-tip", ["ngxTip"], { "status": { "alias": "status"; "required": false; }; "isCloseable": { "alias": "isCloseable"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, { "close": "close"; }, never, ["*"], false, never>;
}

declare class TipModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TipModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TipModule, [typeof TipComponent], [typeof i2.CommonModule, typeof IconModule], [typeof TipComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TipModule>;
}

declare enum PlusMenuPosition {
    Right = "right",
    Bottom = "bottom",
    Top = "top"
}

interface PlusMenuItem {
    title: string;
    subtitle?: string;
    icon: string;
    color?: string;
}
declare class PlusMenuComponent implements OnInit, OnDestroy {
    private readonly elementRef;
    private readonly renderer;
    private readonly cdr;
    items: PlusMenuItem[];
    position: PlusMenuPosition;
    menuTitle: string;
    closeOnClickOutside: boolean;
    menuColor: string;
    clickItem: EventEmitter<any>;
    toggleMenu: EventEmitter<boolean>;
    get itemColor0(): string;
    get itemColor1(): string;
    get itemColor2(): string;
    get p(): string;
    open: boolean;
    get hasThree(): boolean;
    uid: string;
    readonly PlusMenuPosition: typeof PlusMenuPosition;
    private documentClickEvent;
    constructor(elementRef: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onClickOpenClose(): void;
    onClickItem(index: number): void;
    private openMenu;
    private closeMenu;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlusMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlusMenuComponent, "ngx-plus-menu", never, { "items": { "alias": "items"; "required": false; }; "position": { "alias": "position"; "required": false; }; "menuTitle": { "alias": "menuTitle"; "required": false; }; "closeOnClickOutside": { "alias": "closeOnClickOutside"; "required": false; }; "menuColor": { "alias": "menuColor"; "required": false; }; "hasThree": { "alias": "hasThree"; "required": false; }; }, { "clickItem": "clickItem"; "toggleMenu": "toggleMenu"; }, never, never, false, never>;
}

declare class PlusMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlusMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlusMenuModule, [typeof PlusMenuComponent], [typeof i2.CommonModule, typeof IconModule, typeof HotkeysModule, typeof TooltipModule], [typeof PlusMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlusMenuModule>;
}

/**
 * Debounce a function
 *
 * @param func      function to execute
 * @param wait      wait duration
 * @param immediate wait or immediate execute
 */
declare const debounce: (func: () => void, wait: number, immediate?: boolean) => (() => any);

declare const filterByObject: (filter: any) => (value: unknown) => boolean;

declare const filterByString: (filter: string) => (value: string) => boolean;

/**
 * Defatul filterDefault function
 *
 * @param filter
 */
declare const filterDefault: (filter: unknown) => (value: unknown) => boolean;

declare const getType: (item: unknown) => string;

/**
 * Generates a short id.
 *
 * Description:
 * 	A 5-character alphanumeric sequence (364 = 1.6 million)
 * 	This should only be used for JavaScript specific models.
 * 	http://stackoverflow.com/questions/6248666/how-to-generate-short-uid-like-ax4j9z-in-js
 *
 * 	Example: `aebgf`
 */
declare const id: () => string;

declare const isNumber: (value: string | number) => boolean;

declare const CARET_OFFSET = 7;

interface Dimensions {
    top?: number;
    bottom?: number;
    left?: number;
    right?: number;
    height?: number;
    width?: number;
}

/**
 * Calculate horz alignment position
 *
 * @param elDimensions
 * @param popoverDimensions
 * @param alignment
 *
 * @returns number
 */
declare const calculateHorizontalAlignment: (elDimensions: Dimensions, popoverDimensions: Dimensions, alignment: AlignmentTypes) => number;

/**
 * Calculate horz caret position
 *
 * @param elDimensions
 * @param popoverDimensions
 * @param caretDimensions
 * @param alignment
 *
 * @returns number
 */
declare const calculateHorizontalCaret: (elDimensions: Dimensions, popoverDimensions: Dimensions, caretDimensions: Dimensions, alignment: AlignmentTypes) => number;

/**
 * Calculate vertical alignment position
 *
 * @param elDimensions
 * @param popoverDimensions
 * @param alignment
 *
 * @memberOf PositionHelper
 */
declare const calculateVerticalAlignment: (elDimensions: Dimensions, popoverDimensions: Dimensions, alignment: AlignmentTypes) => number;

/**
 * Calculate vertical caret position
 *
 * @param elDimensions
 * @param popoverDimensions
 * @param caretDimensions
 * @param alignment
 *
 * @memberOf PositionHelper
 */
declare const calculateVerticalCaret: (elDimensions: Dimensions, popoverDimensions: Dimensions, caretDimensions: Dimensions, alignment: AlignmentTypes) => number;

/**
 * Determine placement based on flip
 *
 * @param placement
 * @param elmDim
 * @param hostDim
 * @param spacing
 * @param alignment
 *
 * @returns PlacementTypes
 */
declare const determinePlacement: (placement: PlacementTypes, elmDim: Dimensions, hostDim: Dimensions, spacing: number, alignment: AlignmentTypes) => PlacementTypes;

declare const horizontalPosition: (elDimensions: Dimensions, popoverDimensions: Dimensions, alignment: AlignmentTypes) => number;

/**
 * Position caret
 *
 * @param placement
 * @param elmDim
 * @param hostDim
 * @param caretDimensions
 * @param alignment
 *
 * @returns ({ top: number; left: number; })
 */
declare const positionCaret: (placement: PlacementTypes, elmDim: Dimensions, hostDim: Dimensions, caretDimensions: Dimensions, alignment: AlignmentTypes) => {
    top: number;
    left: number;
};

/**
 * Position content
 *
 * @param placement
 * @param elmDim
 * @param hostDim
 * @param spacing
 * @param alignment
 *
 * @returns ({ top: number; left: number; })
 */
declare const positionContent: (placement: PlacementTypes, elmDim: Dimensions, hostDim: Dimensions, spacing: number, alignment: AlignmentTypes) => {
    top: number;
    left: number;
};

/**
 * Checks if the element's position should be flipped
 *
 * @param elDimensions
 * @param popoverDimensions
 * @param placement
 * @param alignment
 * @param spacing
 *
 * @returns boolean
 */
declare const shouldFlip: (elDimensions: Dimensions, popoverDimensions: Dimensions, placement: PlacementTypes, alignment: AlignmentTypes, spacing: number) => boolean;

declare const verticalPosition: (elDimensions: Dimensions, popoverDimensions: Dimensions, alignment: AlignmentTypes) => number;

interface ThrottleOptions {
    leading?: boolean;
    trailing?: boolean;
}

/**
 * Throttle a function
 *
 * @param func    function to execute
 * @param wait    duration to wait
 * @param options options
 * @returns anything
 */
declare function throttle(func: () => void, wait: number, options?: ThrottleOptions): any;

/**
 * Debounce decorator
 *
 *  class MyClass {
 *    debounceable(10)
 *    myFn() { ... }
 *  }
 */
declare function debounceable(duration: number, immediate?: boolean): (_: any, key: string, descriptor: any) => any;

/**
 * Throttle decorator
 *
 *  class MyClass {
 *    throttleable(10)
 *    myFn() { ... }
 *  }
 */
declare function throttleable(duration: number, options?: ThrottleOptions): (_: any, key: string, descriptor: any) => any;

declare class NgxUIModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxUIModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxUIModule, never, [typeof ButtonModule, typeof ButtonGroupModule, typeof CalendarModule, typeof CardModule, typeof CheckboxModule, typeof CodeEditorModule, typeof i2.CommonModule, typeof DateTimeModule, typeof TimeDisplayModule, typeof DialogModule, typeof DirectivesModule, typeof DrawerModule, typeof DropdownModule, typeof DropzoneModule, typeof FiltersModule, typeof i3.FormsModule, typeof HotkeysModule, typeof IconModule, typeof InputModule, typeof JsonEditorModule, typeof LoadingModule, typeof LongPressButtonModule, typeof NagModule, typeof NavbarModule, typeof NavMenuModule, typeof NotificationModule, typeof OverlayModule, typeof PipesModule, typeof PlusMenuModule, typeof ProgressSpinnerModule, typeof RadioButtonModule, typeof SectionModule, typeof SelectModule, typeof SliderModule, typeof SplitModule, typeof StepperModule, typeof TabsModule, typeof TipModule, typeof ToggleModule, typeof ToolbarModule, typeof TooltipModule, typeof TreeModule, typeof ButtonToggleModule], [typeof ButtonModule, typeof ButtonGroupModule, typeof CalendarModule, typeof CardModule, typeof CheckboxModule, typeof CodeEditorModule, typeof i2.CommonModule, typeof DateTimeModule, typeof TimeDisplayModule, typeof DialogModule, typeof DirectivesModule, typeof DrawerModule, typeof DropdownModule, typeof DropzoneModule, typeof FiltersModule, typeof i3.FormsModule, typeof HotkeysModule, typeof IconModule, typeof InputModule, typeof JsonEditorModule, typeof LoadingModule, typeof LongPressButtonModule, typeof NagModule, typeof NavbarModule, typeof NavMenuModule, typeof NotificationModule, typeof OverlayModule, typeof PipesModule, typeof PlusMenuModule, typeof ProgressSpinnerModule, typeof RadioButtonModule, typeof SectionModule, typeof SelectModule, typeof SliderModule, typeof SplitModule, typeof StepperModule, typeof TabsModule, typeof TipModule, typeof ToggleModule, typeof ToolbarModule, typeof TooltipModule, typeof TreeModule, typeof ButtonToggleModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxUIModule>;
}

export { AlertComponent, AlertService, AlertStyles, AlertTypes, AlignmentTypes, ArrayNode, ArrayNodeComponent, ArrayNodeFlatComponent, AutoSizeInputDirective, AutoSizeInputModule, AutosizeDirective, BottonGroupStyle, ButtonComponent, ButtonGroupComponent, ButtonGroupModule, ButtonGroupOrientation, ButtonGroupVariant, ButtonModule, ButtonState, ButtonToggleComponent, ButtonToggleGroupComponent, ButtonToggleModule, CARET_OFFSET, CalendarComponent, CalendarModule, CalendarView, CamelToSnakeModule, CamelToSnakePipe, CardAvatarComponent, CardBodyDirective, CardComponent, CardFooterComponent, CardHeaderComponent, CardModule, CardPlaceholderComponent, CardSectionDirective, CardSubtitleDirective, CardTagDirective, CardTitleDirective, CheckboxComponent, CheckboxModule, CodeEditorComponent, CodeEditorModule, ColumnComponent, ColumnModule, ColumnsComponent, ColumnsModule, DATE_DISPLAY_FORMATS, DATE_DISPLAY_INPUT_FORMATS, DATE_DISPLAY_TYPES, DEFAULT_TOOLTIP_CONFIG, DateRangePickerComponent, DateRangePickerModule, DateTimeComponent, DateTimeModule, DateTimeType, DblClickCopyDirective, DblClickCopyModule, DecamelizeModule, DecamelizePipe, DialogComponent, DialogDrawerContentComponent, DialogFormat, DialogModule, DialogService, DirectivesModule, DrawerComponent, DrawerContainerDirective, DrawerDirection, DrawerModule, DrawerPosition, DrawerService, DropdownComponent, DropdownMenuDirective, DropdownModule, DropdownShowTypes, DropdownToggleDirective, DropzoneComponent, DropzoneModule, DropzoneSize, FileButtonComponent, FileButtonStyleType, FilterComponent, FilterModule, FilterPipe, FiltersModule, HotKey, HotkeyStatus, HotkeysComponent, HotkeysModule, HotkeysService, IconComponent, IconModule, IconRegistryService, IfTabActiveDirective, InjectionRegistryService, InjectionService, InputComponent, InputHintDirective, InputModule, InputPrefixComponent, InputSuffixComponent, InputTypes, JSONTreeModule, JSONTreePipe, JsonEditor, JsonEditorComponent, JsonEditorFlatComponent, JsonEditorModule, JsonEditorNode, JsonEditorNodeComponent, JsonEditorNodeFlatComponent, JsonEditorNodeInfoComponent, LargeFormatDialogContentComponent, LargeFormatDialogFooterComponent, LargeFormatDialogStepperDirective, LargeFormatDialogSubStepperDirective, LargeFormatDialogSubTabsDirective, LargeFormatDialogTabsDirective, ListColumnComponent, ListColumnTemplateDirective, ListComponent, ListHeaderComponent, ListHeaderTemplateDirective, ListModule, ListRowComponent, ListRowStatus, LoadingComponent, LoadingModule, LoadingService, LongPressButtonComponent, LongPressButtonModule, LongPressButtonState, LongPressDirective, LongPressModule, MemoizeModule, MemoizePipe, MultiDimensionSelectionComponent, MultiDimensionSelectionModule, NagComponent, NagModule, NavMenuComponent, NavMenuModule, NavbarComponent, NavbarItemComponent, NavbarModule, NgxTimeDisplayComponent, NgxUIModule, NotificationComponent, NotificationContainerComponent, NotificationModule, NotificationPermissionType, NotificationService, NotificationStyleType, NotificationType, ObjectNode, ObjectNodeComponent, ObjectNodeFlatComponent, ObjectValuesPipe, OrderableInputsListComponent, OverlayComponent, OverlayModule, OverlayService, PatternValidatorDirective, PatternValidatorModule, PipesModule, PlacementTypes, PlusMenuComponent, PlusMenuModule, PlusMenuPosition, ProgressSpinnerComponent, ProgressSpinnerMode, ProgressSpinnerModule, PropertyConfigComponent, RadioButtonComponent, RadioButtonGroupComponent, RadioButtonModule, ResizeObserverDirective, ResizeObserverModule, ResizeOverlayComponent, SchemaValidatorService, SectionComponent, SectionHeaderComponent, SectionModule, SelectComponent, SelectDropdownComponent, SelectInputComponent, SelectModule, SelectOptionDirective, SelectOptionInputTemplateDirective, SelectOptionTemplateDirective, SelectionListComponent, SelectionListModule, ShowTypes, SliderComponent, SliderModule, SpinnerAppearance, SplitAreaDirective, SplitDirection, SplitDirective, SplitHandleComponent, SplitModule, StepComponent, StepContentDirective, StepperComponent, StepperModule, StepperPosition, StyleTypes, TabComponent, TabsComponent, TabsModule, TimeDisplayModule, TimeZoneFormatPipe, TimeZoneModule, TimeZonePipe, TipComponent, TipModule, TipStatus, ToggleComponent, ToggleModule, ToolbarComponent, ToolbarContentDirective, ToolbarModule, ToolbarTitleDirective, TooltipContentComponent, TooltipDirective, TooltipModule, TooltipService, TreeComponent, TreeModule, TreeNodeComponent, VisibilityDirective, VisibilityModule, _activate, _add, _deregister, _pauseOthers, _suspend, _unpauseOthers, bounceAnimation, calculateHorizontalAlignment, calculateHorizontalCaret, calculateVerticalAlignment, calculateVerticalCaret, createValueForSchema, dataTypeMap, debounce, debounceable, determinePlacement, fadeInAnimation, fadeOutAnimation, filterByObject, filterByString, filterDefault, getCurrentType, getIcon, getType, horizontalPosition, id, inferType, isNumber, jsonSchemaDataFormats, jsonSchemaDataTypes, positionCaret, positionContent, propTypes, requiredIndicatorIcon, shouldFlip, slideBottomAnimation, slideDownFadeOutAnimation, slideLeftAnimation, slideRightAnimation, slideTopAnimation, slideUpFadeOutAnimation, throttle, throttleable, validateBasis, verticalPosition };
export type { CalendarDateRange, CalendarDay, CalendarMonth, Column, ColumnCustomComponentOptions, ColumnTabClickEvent, Datelike, DialogOptions, Dimensions, DrawerOptions, FilterCustomDropdown, HintCompletion, JSONEditorSchema, JSONEditorTemplateProperty, JsonSchemaDataType, ListColumnInput, ListPaginationConfig, NotificationOptions, PlusMenuItem, PropertyConfigOptions, PropertyIndex, SelectDropdownOption, SelectionList, SelectionListOption, SpinnerLabel, ThrottleOptions, ToolbarMenuItem, TooltipConfig, TreeNode };